char *remote_crypto_key;
} switch_secure_settings_t;
-typedef struct codec_params_s {
- char *rm_encoding;
- char *iananame;
- switch_payload_t pt;
- unsigned long rm_rate;
- unsigned long adv_rm_rate;
- uint32_t codec_ms;
- uint32_t bitrate;
- char *rm_fmtp;
-
- switch_payload_t agreed_pt;
- switch_payload_t recv_pt;
- char *fmtp_out;
-
-
- char *remote_sdp_ip;
- switch_port_t remote_sdp_port;
-
- 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;
- int channels;
- int adv_channels;
-
-} codec_params_t;
struct media_helper {
switch_core_session_t *session;
int up;
};
+
typedef struct switch_rtp_engine_s {
switch_secure_settings_t ssec;
switch_media_type_t type;
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;
+
+
/** ZRTP **/
char *local_sdp_zrtp_hash;
char *remote_sdp_zrtp_hash;
+ payload_map_t *cur_payload_map;
+ payload_map_t *payload_map;
+ payload_map_t *pmap_tail;
- codec_params_t codec_params;
uint32_t timestamp_send;
char *cand_acl[SWITCH_MAX_CAND_ACL];
switch_thread_t *media_thread;
switch_mutex_t *read_mutex;
+ uint8_t reset_codec;
+ uint8_t codec_negotiated;
} switch_rtp_engine_t;
remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);
- a_engine->codec_params.remote_sdp_ip = switch_core_session_strdup(session, t38_options->remote_ip);
- a_engine->codec_params.remote_sdp_port = t38_options->remote_port;
+ 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->codec_params.remote_sdp_ip) &&
- remote_port == a_engine->codec_params.remote_sdp_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));
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->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ 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->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->codec_params.remote_sdp_ip);
+ 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->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
+ 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_DECLARE(payload_map_t *) switch_core_media_add_payload_map(switch_core_session_t *session,
+ switch_media_type_t type,
+ const char *name,
+ switch_sdp_type_t sdp_type,
+ uint32_t pt,
+ uint32_t rate,
+ uint32_t ptime,
+ 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->mutex);
+
+
+ for (pmap = engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {
+ exists = (!strcasecmp(name, pmap->iananame) && rate == pmap->rate && pmap->ptime == ptime);
+
+ if (exists) {
+ break;
+ }
+ }
+
+
+ if (!exists) {
+ if (engine->payload_map && !engine->payload_map->allocated) {
+ pmap = engine->payload_map;
+ } else {
+ pmap = switch_core_alloc(session->pool, sizeof(*pmap));
+ }
+
+ pmap->sdp_type = sdp_type;
+ pmap->type = type;
+ pmap->iananame = switch_core_strdup(session->pool, name);
+ pmap->rm_encoding = pmap->iananame;
+ pmap->ptime = ptime;
+ pmap->rate = rate;
+ }
+
+ pmap->allocated = 1;
+ pmap->recv_pt = pt;
+
+ if (sdp_type == SDP_TYPE_REQUEST || !exists) {
+ pmap->pt = pt;
+ }
+
+ if (negotiated) {
+ pmap->negotiated = negotiated;
+ }
+
+ if (!exists) {
+ 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->mutex);
+
+ return pmap;
+}
{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_media_handle_t *smh = NULL;
-
-
*smhp = NULL;
if (zstr(params->sdp_username)) {
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->mparams = params;
+
switch_mutex_init(&session->media_handle->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].ssrc =
session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].ssrc =
(uint32_t) ((intptr_t) &session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO] + (uint32_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_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;
+
+
switch_channel_set_flag(session->channel, CF_DTLS_OK);
status = SWITCH_STATUS_SUCCESS;
switch_rtp_engine_t *engine;
switch_status_t status;
switch_media_handle_t *smh;
+ int do_cng = 0;
switch_assert(session);
goto end;
}
+ /* re-set codec if necessary */
+ if (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)) {
+ if (switch_core_media_set_codec(session, 1, 0) != SWITCH_STATUS_SUCCESS) {
+ *frame = NULL;
+ switch_goto_status(SWITCH_STATUS_GENERR, end);
+ }
+
+ if ((val = switch_channel_get_variable(session->channel, "rtp_timeout_sec"))) {
+ int v = atoi(val);
+ if (v >= 0) {
+ rtp_timeout_sec = v;
+ }
+ }
+
+ if ((val = switch_channel_get_variable(session->channel, "rtp_hold_timeout_sec"))) {
+ int v = atoi(val);
+ if (v >= 0) {
+ 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;
+ }
+ }
+
+
+ if (session->read_resampler) {
+ switch_mutex_lock(session->resample_mutex);
+ switch_resample_destroy(&session->read_resampler);
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Deactivating read resampler\n");
+ switch_mutex_unlock(session->resample_mutex);
+ }
+
+ 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_reset(session, 0, 0);
+
+
+ engine->check_frames = 0;
+ engine->last_ts = 0;
+
+ switch_channel_audio_sync(session->channel);
+ 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;
switch_rtp_dequeue_dtmf(engine->rtp_session, &dtmf);
switch_channel_queue_dtmf(session->channel, &dtmf);
}
-
+
if (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] && engine->check_frames < MAX_CODEC_CHECK_FRAMES) {
- /* check for timing or codec issues */
- if ((smh->media_flags[SCMF_AUTOFIX_TIMING] || smh->media_flags[SCMF_AUTOFIX_PT]) &&
- engine->check_frames < MAX_CODEC_CHECK_FRAMES) {
-
- int reset_codec = 0;
engine->check_frames++;
engine->check_frames = MAX_CODEC_CHECK_FRAMES;
goto skip;
}
-
- /* autofix payload type */
- if (smh->media_flags[SCMF_AUTOFIX_PT] &&
- engine->read_frame.payload != smh->mparams->cng_pt &&
- engine->read_frame.payload != smh->mparams->recv_te &&
- engine->read_frame.payload != smh->mparams->te &&
- engine->read_frame.payload != engine->codec_params.recv_pt &&
- engine->read_frame.payload != engine->codec_params.agreed_pt &&
- engine->read_frame.payload != engine->codec_params.pt) {
-
- int i = 0;
-
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
- "Invalid payload received (received %d, expecting %d). "
- "FS doesn't support multiple payload types in a single RTP session.\n",
- (int) engine->read_frame.payload, (int) engine->codec_params.agreed_pt);
-
- /* search for payload type */
- for (i = 0; i < smh->mparams->num_codecs; i++) {
- if (engine->read_frame.payload == smh->ianacodes[i]) {
- const switch_codec_implementation_t *imp = smh->codecs[i];
-
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
- "Changing current codec to %s (payload type %d).\n",
- imp->iananame, (int) engine->read_frame.payload);
-
- engine->codec_params.iananame = switch_core_session_strdup(smh->session, imp->iananame);
- engine->codec_params.pt = imp->ianacode;
- engine->codec_params.agreed_pt = imp->ianacode;
- engine->codec_params.recv_pt = imp->ianacode;
- engine->codec_params.rm_encoding = switch_core_session_strdup(smh->session, imp->iananame);
- engine->codec_params.rm_fmtp = NULL;
- engine->codec_params.rm_rate = imp->samples_per_second;
- engine->codec_params.adv_rm_rate = imp->samples_per_second;
- if (strcasecmp(imp->iananame, "g722")) {
- engine->codec_params.rm_rate = imp->actual_samples_per_second;
- }
- engine->codec_params.codec_ms = imp->microseconds_per_packet / 1000;
- engine->codec_params.bitrate = imp->bits_per_second;
- engine->codec_params.channels = 1;
-
- /* mark to re-set codec */
- reset_codec = 1;
- break;
- }
- }
-
- if (!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);
- }
-
- /* autofix timing */
- } else if (smh->media_flags[SCMF_AUTOFIX_TIMING] && (engine->read_frame.datalen % 10) == 0) {
-
+
+ if (smh->media_flags[SCMF_AUTOFIX_TIMING] && (engine->read_frame.datalen % 10) == 0) {
+
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_codec_ms = codec_ms;
if (engine->mismatch_count > MAX_MISMATCH_FRAMES) {
- if (codec_ms != engine->codec_params.codec_ms) {
+ 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,
engine->read_frame.datalen = 0;
- if (codec_ms != engine->codec_params.codec_ms) {
+ if (codec_ms != engine->cur_payload_map->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) engine->codec_params.codec_ms,
+ (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->codec_params.codec_ms, (int) codec_ms);
+ (int) engine->cur_payload_map->codec_ms, (int) codec_ms);
- engine->codec_params.codec_ms = codec_ms;
+ engine->cur_payload_map->codec_ms = codec_ms;
/* mark to re-set codec */
- reset_codec = 2;
+ engine->reset_codec = 2;
}
}
}
engine->mismatch_count = 0;
engine->last_ts = 0;
}
+ }
- /* re-set codec if necessary */
- if (reset_codec > 0) {
- const char *val;
- int rtp_timeout_sec = 0;
- int rtp_hold_timeout_sec = 0;
+ /* autofix payload type */
- if (switch_rtp_ready(engine->rtp_session)) {
- if (switch_core_media_set_codec(session, 2, 0) != SWITCH_STATUS_SUCCESS) {
- *frame = NULL;
- switch_goto_status(SWITCH_STATUS_GENERR, end);
- }
-
- if ((val = switch_channel_get_variable(session->channel, "rtp_timeout_sec"))) {
- int v = atoi(val);
- if (v >= 0) {
- rtp_timeout_sec = v;
- }
- }
+ if (!engine->reset_codec &&
+ engine->codec_negotiated &&
+ engine->read_frame.payload != smh->mparams->cng_pt &&
+ engine->read_frame.payload != smh->mparams->recv_te &&
+ engine->read_frame.payload != smh->mparams->te &&
+ engine->read_frame.payload != engine->cur_payload_map->recv_pt &&
+ engine->read_frame.payload != engine->cur_payload_map->agreed_pt &&
+ engine->read_frame.payload != engine->cur_payload_map->pt) {
+
+ payload_map_t *pmap;
+
- if ((val = switch_channel_get_variable(session->channel, "rtp_hold_timeout_sec"))) {
- int v = atoi(val);
- if (v >= 0) {
- rtp_hold_timeout_sec = v;
- }
- }
+ 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->agreed_pt);
- 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;
- }
- }
+ /* search for payload type */
+ switch_mutex_lock(smh->mutex);
+ for (pmap = engine->cur_payload_map; pmap; pmap = pmap->next) {
+ if (engine->read_frame.payload == pmap->recv_pt) {
+ engine->cur_payload_map = pmap;
- 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;
- }
+ 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;
}
-
- engine->check_frames = 0;
- engine->last_ts = 0;
-
- /* 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);
+ }
+ switch_mutex_unlock(smh->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);
}
}
engine = &smh->engines[type];
-
while (!(engine->read_codec.implementation && switch_rtp_ready(engine->rtp_session))) {
if (switch_channel_ready(session->channel)) {
switch_yield(10000);
v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
- if (!v_engine->codec_params.rm_encoding) {
+ if (!v_engine->codec_negotiated) {
return SWITCH_STATUS_FALSE;
}
if (!force) {
return SWITCH_STATUS_SUCCESS;
}
- if (strcasecmp(v_engine->read_codec.implementation->iananame, v_engine->codec_params.rm_encoding) ||
- v_engine->read_codec.implementation->samples_per_second != v_engine->codec_params.rm_rate) {
+ 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->codec_params.rm_encoding);
+ 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 {
if (switch_core_codec_init(&v_engine->read_codec,
- v_engine->codec_params.rm_encoding,
- v_engine->codec_params.rm_fmtp,
- v_engine->codec_params.rm_rate,
+ v_engine->cur_payload_map->rm_encoding,
+ v_engine->cur_payload_map->rm_fmtp,
+ v_engine->cur_payload_map->rm_rate,
0,
1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
return SWITCH_STATUS_FALSE;
} else {
if (switch_core_codec_init(&v_engine->write_codec,
- v_engine->codec_params.rm_encoding,
- v_engine->codec_params.rm_fmtp,
- v_engine->codec_params.rm_rate,
+ v_engine->cur_payload_map->rm_encoding,
+ v_engine->cur_payload_map->rm_fmtp,
+ v_engine->cur_payload_map->rm_rate,
0,
1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
return SWITCH_STATUS_FALSE;
} else {
- v_engine->read_frame.rate = v_engine->codec_params.rm_rate;
+ 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->codec_params.rm_encoding,
- v_engine->codec_params.rm_rate, v_engine->codec_params.codec_ms);
+ 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->codec_params.agreed_pt;
- v_engine->read_codec.agreed_pt = v_engine->codec_params.agreed_pt;
+ v_engine->write_codec.agreed_pt = v_engine->cur_payload_map->agreed_pt;
+ v_engine->read_codec.agreed_pt = v_engine->cur_payload_map->agreed_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->codec_params.rm_encoding, v_engine->codec_params.rm_rate);
+ v_engine->cur_payload_map->rm_encoding, v_engine->cur_payload_map->rm_rate);
if (switch_rtp_ready(v_engine->rtp_session)) {
msg.from = __FILE__;
msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;
- switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->codec_params.agreed_pt);
+ switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
- if (v_engine->codec_params.recv_pt != v_engine->codec_params.agreed_pt) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Set video receive payload to %u\n", switch_channel_get_name(session->channel), v_engine->codec_params.recv_pt);
-
- switch_rtp_set_recv_pt(v_engine->rtp_session, v_engine->codec_params.recv_pt);
- } else {
- switch_rtp_set_recv_pt(v_engine->rtp_session, v_engine->codec_params.agreed_pt);
- }
+ //XX
switch_core_session_receive_message(session, &msg);
}
- switch_channel_set_variable(session->channel, "rtp_use_video_codec_name", v_engine->codec_params.rm_encoding);
- switch_channel_set_variable(session->channel, "rtp_use_video_codec_fmtp", v_engine->codec_params.rm_fmtp);
- switch_channel_set_variable_printf(session->channel, "rtp_use_video_codec_rate", "%d", v_engine->codec_params.rm_rate);
+ 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);
}
}
a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
- if (!a_engine->codec_params.iananame) {
+ 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 (!force) {
switch_goto_status(SWITCH_STATUS_SUCCESS, end);
}
- if (strcasecmp(a_engine->read_impl.iananame, a_engine->codec_params.rm_encoding) ||
- (uint32_t) a_engine->read_impl.microseconds_per_packet / 1000 != a_engine->codec_params.codec_ms ||
- a_engine->read_impl.samples_per_second != a_engine->codec_params.rm_rate ) {
+ 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_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
a_engine->read_impl.microseconds_per_packet / 1000,
a_engine->read_impl.samples_per_second,
- a_engine->codec_params.rm_encoding,
- a_engine->codec_params.codec_ms,
- a_engine->codec_params.rm_rate);
+ a_engine->cur_payload_map->iananame,
+ a_engine->cur_payload_map->codec_ms,
+ a_engine->cur_payload_map->rm_rate);
switch_yield(a_engine->read_impl.microseconds_per_packet);
switch_core_session_lock_codec_write(session);
}
if (switch_core_codec_init_with_bitrate(&a_engine->read_codec,
- a_engine->codec_params.iananame,
- a_engine->codec_params.rm_fmtp,
- a_engine->codec_params.rm_rate,
- a_engine->codec_params.codec_ms,
- a_engine->codec_params.channels,
- a_engine->codec_params.bitrate,
+ a_engine->cur_payload_map->iananame,
+ 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,
NULL, 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");
if (switch_core_codec_init_with_bitrate(&a_engine->write_codec,
- a_engine->codec_params.iananame,
- a_engine->codec_params.rm_fmtp,
- a_engine->codec_params.rm_rate,
- a_engine->codec_params.codec_ms,
- a_engine->codec_params.channels,
- a_engine->codec_params.bitrate,
+ a_engine->cur_payload_map->iananame,
+ 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,
NULL, 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");
a_engine->write_codec.session = session;
- switch_channel_set_variable(session->channel, "rtp_use_codec_name", a_engine->codec_params.iananame);
- switch_channel_set_variable(session->channel, "rtp_use_codec_fmtp", a_engine->codec_params.rm_fmtp);
- switch_channel_set_variable_printf(session->channel, "rtp_use_codec_rate", "%d", a_engine->codec_params.rm_rate);
- switch_channel_set_variable_printf(session->channel, "rtp_use_codec_ptime", "%d", a_engine->codec_params.codec_ms);
+ 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_last_audio_codec_string", "%s@%dh@%di",
- a_engine->codec_params.iananame, a_engine->codec_params.rm_rate, a_engine->codec_params.codec_ms);
+ a_engine->cur_payload_map->iananame, a_engine->cur_payload_map->rm_rate, a_engine->cur_payload_map->codec_ms);
switch_assert(a_engine->read_codec.implementation);
switch_assert(a_engine->write_codec.implementation);
}
}
- a_engine->read_frame.rate = a_engine->codec_params.rm_rate;
+ 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_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples %d bits\n",
- switch_channel_get_name(session->channel), a_engine->codec_params.iananame, a_engine->codec_params.rm_rate,
- a_engine->codec_params.codec_ms,
+ 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_frame.codec = &a_engine->read_codec;
- a_engine->write_codec.agreed_pt = a_engine->codec_params.agreed_pt;
- a_engine->read_codec.agreed_pt = a_engine->codec_params.agreed_pt;
+ a_engine->write_codec.agreed_pt = a_engine->cur_payload_map->agreed_pt;
+ a_engine->read_codec.agreed_pt = a_engine->cur_payload_map->agreed_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->codec_params.fmtp_out = switch_core_session_strdup(session, a_engine->write_codec.fmtp_out);
+ 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->codec_params.pt);
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->read_codec.agreed_pt);
+ switch_rtp_set_default_payload(a_engine->rtp_session, a_engine->cur_payload_map->pt);
}
end:
+
if (resetting) {
switch_core_session_unlock_codec_write(session);
switch_core_session_unlock_codec_read(session);
}
- switch_core_media_set_video_codec(session, force);
-
return status;
}
#ifdef RTCP_MUX
} else if (!strcasecmp(attr->a_name, "rtcp-mux")) {
engine->rtcp_mux = SWITCH_TRUE;
- engine->remote_rtcp_port = engine->codec_params.remote_sdp_port;
+ engine->remote_rtcp_port = engine->cur_payload_map->remote_sdp_port;
got_rtcp_mux++;
#endif
} else if (!strcasecmp(attr->a_name, "candidate")) {
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] = "";
- engine->codec_params.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_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_NOTICE,
"setting remote %s ice addr to %s:%d based on candidate\n", type2str(type),
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->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->codec_params.remote_sdp_ip = switch_core_session_strdup(smh->session, (char *) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
- engine->codec_params.remote_sdp_port = (switch_port_t) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port;
+ 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 (engine->remote_rtcp_port) {
- engine->remote_rtcp_port = engine->codec_params.remote_sdp_port;
+ engine->remote_rtcp_port = engine->cur_payload_map->remote_sdp_port;
}
- switch_snprintf(tmp, sizeof(tmp), "%d", engine->codec_params.remote_sdp_port);
- switch_channel_set_variable(smh->session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, engine->codec_params.remote_sdp_ip);
+ switch_snprintf(tmp, sizeof(tmp), "%d", engine->cur_payload_map->remote_sdp_port);
+ switch_channel_set_variable(smh->session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, engine->cur_payload_map->remote_sdp_ip);
switch_channel_set_variable(smh->session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);
}
smh->mparams->rtcp_video_interval_msec = "10000";
}
+#define MAX_MATCHES 30
+struct matches {
+ const switch_codec_implementation_t *imp;
+ sdp_rtpmap_t *map;
+ int rate;
+ int codec_idx;
+};
+
+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 } };
+ for(j = 0; j < m_idx; j++) {
+ *&mtmp[j] = *&matches[j];
+ }
+ for (g = 0; g < smh->mparams->num_codecs && g < total_codecs; g++) {
+ const switch_codec_implementation_t *imp = codec_array[g];
+
+ for(j = 0; j < m_idx; j++) {
+ if (mtmp[j].imp == imp) {
+ *&matches[f++] = *&mtmp[j];
+ }
+ }
+ }
+}
+
+static void clear_pmaps(switch_rtp_engine_t *engine)
+{
+ payload_map_t *pmap;
+
+ for (pmap = engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
+ pmap->negotiated = 0;
+ }
+}
+
//?
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)
{
switch_payload_t best_te = 0, te = 0, cng_pt = 0;
sdp_media_t *m;
sdp_attribute_t *attr;
- int first = 0, last = 0;
int ptime = 0, dptime = 0, maxptime = 0, dmaxptime = 0;
int sendonly = 0, recvonly = 0;
- int greedy = 0, x = 0, skip = 0, mine = 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;
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;
+ int nm_idx = 0;
switch_assert(session);
switch_channel_clear_flag(smh->session->channel, CF_DTLS);
}
+ clear_pmaps(a_engine);
+ clear_pmaps(v_engine);
+
+
if (proceed) *proceed = 1;
greedy = !!switch_media_handle_test_media_flag(smh, SCMF_CODEC_GREEDY);
check_ice(smh, SWITCH_MEDIA_TYPE_AUDIO, sdp, NULL);
check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, NULL);
+
for (m = sdp->sdp_media; m; m = m->m_next) {
sdp_connection_t *connection;
switch_core_session_t *other_session;
switch_channel_set_variable(other_channel, "t38_broken_boolean", "true");
}
- a_engine->codec_params.remote_sdp_ip = switch_core_session_strdup(session, t38_options->remote_ip);
- a_engine->codec_params.remote_sdp_port = t38_options->remote_port;
+ 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->codec_params.remote_sdp_ip) && remote_port == a_engine->codec_params.remote_sdp_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 {
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->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ 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->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->codec_params.remote_sdp_ip);
+ 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->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
+ 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);
}
break;
}
- greed:
x = 0;
- if (a_engine->codec_params.rm_encoding && !(switch_media_handle_test_media_flag(smh, SCMF_LIBERAL_DTMF) ||
+ if (a_engine->cur_payload_map->rm_encoding && !(switch_media_handle_test_media_flag(smh, SCMF_LIBERAL_DTMF) ||
switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF))) { // && !switch_channel_test_flag(session->channel, CF_REINVITE)) {
- char *remote_host = a_engine->codec_params.remote_sdp_ip;
- switch_port_t remote_port = a_engine->codec_params.remote_sdp_port;
+ char *remote_host = a_engine->cur_payload_map->remote_sdp_ip;
+ switch_port_t remote_port = a_engine->cur_payload_map->remote_sdp_port;
int same = 0;
if (switch_rtp_ready(a_engine->rtp_session)) {
for (map = m->m_rtpmaps; map; map = map->rm_next) {
if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
- match = (map->rm_pt == a_engine->codec_params.pt) ? 1 : 0;
+ match = (map->rm_pt == a_engine->cur_payload_map->pt) ? 1 : 0;
} else {
- match = strcasecmp(switch_str_nil(map->rm_encoding), a_engine->codec_params.iananame) ? 0 : 1;
+ match = strcasecmp(switch_str_nil(map->rm_encoding), a_engine->cur_payload_map->iananame) ? 0 : 1;
}
if (match && connection->c_address && remote_host && !strcmp(connection->c_address, remote_host) && m->m_port == remote_port) {
if (same) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
"Our existing sdp is still good [%s %s:%d], let's keep it.\n",
- a_engine->codec_params.rm_encoding, a_engine->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ a_engine->cur_payload_map->rm_encoding, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
got_audio = 1;
} else {
match = 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 };
+
if (!(rm_encoding = map->rm_encoding)) {
rm_encoding = "";
}
-
-
+
+
if (!strcasecmp(rm_encoding, "telephone-event")) {
- if (!best_te || map->rm_rate == a_engine->codec_params.rm_rate) {
+ if (!best_te || map->rm_rate == a_engine->cur_payload_map->rm_rate) {
best_te = (switch_payload_t) map->rm_pt;
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set telephone-event payload to %u\n", best_te);
}
+ continue;
}
if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && !cng_pt && !strcasecmp(rm_encoding, "CN")) {
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, smh->mparams->cng_pt);
}
+ continue;
}
-
- }
-
- 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 };
-
+
+
if (x++ < skip) {
continue;
}
- if (!(rm_encoding = map->rm_encoding)) {
- rm_encoding = "";
- }
-
if (match) {
continue;
}
- if (greedy) {
- first = mine;
- last = first + 1;
- } else {
- first = 0;
- last = smh->mparams->num_codecs;
- }
-
codec_ms = ptime;
if (maxptime && (!codec_ms || codec_ms > maxptime)) {
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;
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;
+ }
}
}
-
- for (i = first; i < last && i < total_codecs; i++) {
+ 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;
- char *samp = NULL;
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]/[%s:%d:%u:%d:%u]\n",
- rm_encoding, map->rm_pt, (int) map->rm_rate, codec_ms, map_bit_rate,
+ rm_encoding, map->rm_pt, (int) remote_codec_rate, codec_ms, map_bit_rate,
imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate);
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_rate == codec_rate)) ? 1 : 0;
+ match = (!strcasecmp(rm_encoding, imp->iananame) &&
+ (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") &&
match = 0;
}
- if (match && map->rm_rate && codec_rate && map->rm_rate != codec_rate && (!strcasecmp(map->rm_encoding, "pcma") ||
+ 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 (!zstr(map->rm_fmtp)) {
- samp = strstr(map->rm_fmtp, "samplerate=");
- }
- if (!strcasecmp(map->rm_encoding, "opus") && !strcasecmp(rm_encoding, imp->iananame) && samp) {
- char *rate_str = samp + 11;
-
- if (rate_str && *rate_str) {
- near_rate = atoi(rate_str);
- near_match = imp;
- near_map = mmap = map;
- match = 0;
- goto near_match;
- }
- }
-
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) || map->rm_rate != codec_rate) {
+ } else if ((ptime && codec_ms && codec_ms * 1000 != imp->microseconds_per_packet) || remote_codec_rate != codec_rate) {
/* ptime does not match */
match = 0;
+
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
+ "Audio Codec Compare [%s:%d:%u:%d:%u] is saved as a near-match\n",
+ imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate);
- /* save first near_match */
- if (!near_match) {
- near_rate = map->rm_rate;
- near_match = imp;
- near_map = mmap = map;
+ 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++;
- if (switch_true(switch_channel_get_variable_dup(channel, "rtp_negotiate_near_match", SWITCH_FALSE, -1))) {
- goto near_match;
- }
- }
continue;
}
- mimp = imp;
- mmap = map;
- break;
- }
- }
-
- if (!match && greedy) {
- skip++;
- 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] ++++ is saved as a match\n",
+ imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate);
+
+ if (m_idx >= MAX_MATCHES) {
+ break;
+ }
+
+ match = 0;
+ }
}
- if (match && mimp) {
+ if (m_idx >= MAX_MATCHES) {
break;
}
}
- near_match:
+ if (!m_idx && nm_idx) {
+ int j;
- if (!match && near_match) {
- const switch_codec_implementation_t *search[1];
- char *prefs[1];
- char tmp[80];
- int num;
-
- switch_snprintf(tmp, sizeof(tmp), "%s@%uh@%ui", near_match->iananame, near_rate ? near_rate : near_match->samples_per_second,
- codec_ms);
-
- prefs[0] = tmp;
- num = switch_loadable_module_get_codecs_sorted(search, 1, prefs, 1);
+ for(j = 0; j < nm_idx; j++) {
+ const switch_codec_implementation_t *search[1];
+ char *prefs[1];
+ char tmp[80];
+ 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", near_match->iananame, near_rate ? near_rate : near_match->samples_per_second,
+ codec_ms);
+
+ prefs[0] = tmp;
+ num = switch_loadable_module_get_codecs_sorted(search, 1, prefs, 1);
- if (num) {
- mimp = search[0];
- } else {
- mimp = near_match;
- }
+ if (num) {
+ timp = search[0];
+ } else {
+ timp = near_match;
+ }
- if (!maxptime || mimp->microseconds_per_packet / 1000 <= maxptime) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Substituting codec %s@%ui@%uh\n",
- mimp->iananame, mimp->microseconds_per_packet / 1000, mimp->samples_per_second);
- mmap = near_map;
- match = 1;
- } else {
- mimp = NULL;
- mmap = NULL;
- match = 0;
+ if (!maxptime || timp->microseconds_per_packet / 1000 <= maxptime) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Substituting codec %s@%ui@%uh\n",
+ timp->iananame, timp->microseconds_per_packet / 1000, timp->actual_samples_per_second);
+ 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 (mimp && mmap) {
- char tmp[50];
- const char *mirror = switch_channel_get_variable(session->channel, "rtp_mirror_remote_audio_codec_payload");
+ if (m_idx) {
+ int j;
- a_engine->codec_params.rm_encoding = switch_core_session_strdup(session, (char *) mmap->rm_encoding);
- a_engine->codec_params.iananame = switch_core_session_strdup(session, (char *) mimp->iananame);
- a_engine->codec_params.pt = (switch_payload_t) mmap->rm_pt;
- a_engine->codec_params.rm_rate = mimp->samples_per_second;
- a_engine->codec_params.adv_rm_rate = mimp->samples_per_second;
- if (strcasecmp(mimp->iananame, "g722")) {
- a_engine->codec_params.rm_rate = mimp->actual_samples_per_second;
- }
- a_engine->codec_params.codec_ms = mimp->microseconds_per_packet / 1000;
- a_engine->codec_params.bitrate = mimp->bits_per_second;
- a_engine->codec_params.channels = mmap->rm_params ? atoi(mmap->rm_params) : 1;
-
- if (!strcasecmp((char *) mmap->rm_encoding, "opus")) {
- if (a_engine->codec_params.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");
- a_engine->codec_params.adv_channels = 1;
- } else {
- a_engine->codec_params.adv_channels = 2; /* IKR ???*/
+ 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; j++) {
+ payload_map_t *pmap = switch_core_media_add_payload_map(session,
+ SWITCH_MEDIA_TYPE_AUDIO,
+ matches[j].map->rm_encoding,
+ sdp_type,
+ matches[j].map->rm_pt,
+ matches[j].imp->samples_per_second,
+ matches[j].imp->microseconds_per_packet / 1000,
+ SWITCH_TRUE);
+ mimp = matches[j].imp;
+ mmap = matches[j].map;
+
+ if (j == 0) {
+ a_engine->cur_payload_map = pmap;
}
- if (!zstr((char *) mmap->rm_fmtp) && switch_stristr("stereo=1", (char *) mmap->rm_fmtp)) {
- a_engine->codec_params.channels = 2;
+
+ pmap->rm_encoding = switch_core_session_strdup(session, (char *) mmap->rm_encoding);
+ pmap->iananame = switch_core_session_strdup(session, (char *) mimp->iananame);
+ pmap->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)) {
+ pmap->channels = 2;
+ } else {
+ pmap->channels = 1;
+ }
} else {
- a_engine->codec_params.channels = 1;
+ pmap->adv_channels = pmap->channels;
}
- } else {
- a_engine->codec_params.adv_channels = a_engine->codec_params.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);
+
+ pmap->agreed_pt = (switch_payload_t) mmap->rm_pt;
+ smh->num_negotiated_codecs = 0;
+ smh->negotiated_codecs[smh->num_negotiated_codecs++] = mimp;
+ pmap->recv_pt = (switch_payload_t)mmap->rm_pt;
+
}
-
- a_engine->codec_params.remote_sdp_ip = switch_core_session_strdup(session, (char *) connection->c_address);
- a_engine->codec_params.remote_sdp_port = (switch_port_t) m->m_port;
- a_engine->codec_params.rm_fmtp = switch_core_session_strdup(session, (char *) mmap->rm_fmtp);
+ }
- a_engine->codec_params.agreed_pt = (switch_payload_t) mmap->rm_pt;
- smh->num_negotiated_codecs = 0;
- smh->negotiated_codecs[smh->num_negotiated_codecs++] = mimp;
- switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->codec_params.remote_sdp_ip);
+ 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);
- a_engine->codec_params.recv_pt = (switch_payload_t)mmap->rm_pt;
-
+
+
if (!switch_true(mirror) &&
switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND &&
(!switch_channel_test_flag(session->channel, CF_REINVITE) || switch_media_handle_test_media_flag(smh, SCMF_RENEG_ON_REINVITE))) {
- switch_core_media_get_offered_pt(session, mimp, &a_engine->codec_params.recv_pt);
+ switch_core_media_get_offered_pt(session, mimp, &a_engine->cur_payload_map->recv_pt);
}
-
- switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->codec_params.recv_pt);
+
+ 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 (match) {
- if (switch_core_media_set_codec(session, 1, smh->mparams->codec_flags) == SWITCH_STATUS_SUCCESS) {
+ if (switch_core_codec_ready(&a_engine->read_codec)) {
+ a_engine->reset_codec = 1;
+ }
+
+ if (switch_core_media_set_codec(session, 0, smh->mparams->codec_flags) == SWITCH_STATUS_SUCCESS) {
got_audio = 1;
check_ice(smh, SWITCH_MEDIA_TYPE_AUDIO, sdp, m);
} else {
}
}
-
- if (!match && greedy && mine < total_codecs) {
- mine++;
- skip = 0;
- goto greed;
- }
-
} else if (m->m_type == sdp_media_video && m->m_port) {
sdp_rtpmap_t *map;
const char *rm_encoding;
const switch_codec_implementation_t *mimp = NULL;
int vmatch = 0, i;
+
+ nm_idx = 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");
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;
}
}
}
-
+
for (attr = m->m_attributes; attr; attr = attr->a_next) {
if (!strcasecmp(attr->a_name, "framerate") && attr->a_value) {
//framerate = atoi(attr->a_value);
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) {
if (vmatch && (map->rm_rate == imp->samples_per_second)) {
- mimp = imp;
- break;
- } else {
- vmatch = 0;
+ 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, imp->ianacode);
+ m_idx++;
}
+
+ vmatch = 0;
}
+ }
- if (mimp) {
- if ((v_engine->codec_params.rm_encoding = switch_core_session_strdup(session, (char *) rm_encoding))) {
- char tmp[50];
- const char *mirror = switch_channel_get_variable(session->channel, "rtp_mirror_remote_video_codec_payload");
+ if (m_idx) {
+ char tmp[50];
+ const char *mirror = switch_channel_get_variable(session->channel, "rtp_mirror_remote_video_codec_payload");
+ int j = 0;
- v_engine->codec_params.pt = (switch_payload_t) map->rm_pt;
- v_engine->codec_params.rm_rate = map->rm_rate;
- v_engine->codec_params.codec_ms = mimp->microseconds_per_packet / 1000;
+ 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->codec_params.remote_sdp_ip = switch_core_session_strdup(session, (char *) connection->c_address);
- v_engine->codec_params.remote_sdp_port = (switch_port_t) m->m_port;
+ for(j = 0; j < m_idx; j++) {
+ payload_map_t *pmap = switch_core_media_add_payload_map(session,
+ SWITCH_MEDIA_TYPE_VIDEO,
+ matches[j].map->rm_encoding,
+ sdp_type,
+ matches[j].map->rm_pt,
+ matches[j].imp->samples_per_second,
+ matches[j].imp->microseconds_per_packet / 1000,
+ SWITCH_TRUE);
+
+ if (j == 0) {
+ v_engine->cur_payload_map = pmap;
+ }
+
+ mimp = matches[j].imp;
+ map = matches[j].map;
+
+ pmap->rm_encoding = switch_core_session_strdup(session, (char *) map->rm_encoding);
+ pmap->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;
- v_engine->codec_params.rm_fmtp = switch_core_session_strdup(session, (char *) map->rm_fmtp);
-
- v_engine->codec_params.agreed_pt = (switch_payload_t) map->rm_pt;
- switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_VIDEO_IP_VARIABLE, v_engine->codec_params.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->codec_params.rm_fmtp);
- switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->codec_params.agreed_pt);
- switch_channel_set_variable(session->channel, "rtp_video_pt", tmp);
- switch_core_media_check_video_codecs(session);
-
- v_engine->codec_params.recv_pt = (switch_payload_t)map->rm_pt;
+ pmap->rm_fmtp = switch_core_session_strdup(session, (char *) map->rm_fmtp);
+
+ pmap->agreed_pt = (switch_payload_t) map->rm_pt;
+
+ pmap->recv_pt = (switch_payload_t)map->rm_pt;
- if (!switch_true(mirror) && switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
- switch_core_media_get_offered_pt(session, mimp, &v_engine->codec_params.recv_pt);
- }
+ if (!switch_true(mirror) && switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
+ switch_core_media_get_offered_pt(session, mimp, &pmap->recv_pt);
+ }
+ }
- switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->codec_params.recv_pt);
- switch_channel_set_variable(session->channel, "rtp_video_recv_pt", tmp);
- if (!match && vmatch) match = 1;
+
+
+ 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->agreed_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 (!match && vmatch) match = 1;
- check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, m);
- //check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, NULL);
- break;
- } else {
- vmatch = 0;
- }
+ if (switch_core_codec_ready(&v_engine->read_codec)) {
+ v_engine->reset_codec = 1;
+ }
+
+ if (switch_core_media_set_video_codec(session, 0) == SWITCH_STATUS_SUCCESS) {
+ check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, m);
}
+
}
-
}
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "%s Starting Video thread\n", switch_core_session_get_name(session));
- switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->codec_params.agreed_pt);
+ switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
v_engine->mh.session = session;
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
goto end;
}
- a_engine->codec_params.remote_sdp_ip = switch_core_session_strdup(session, rip);
- a_engine->codec_params.remote_sdp_port = (switch_port_t) atoi(rp);
+ 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->codec_params.remote_sdp_ip = switch_core_session_strdup(session, rip);
- v_engine->codec_params.remote_sdp_port = (switch_port_t) atoi(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 (v_engine->codec_params.remote_sdp_ip && v_engine->codec_params.remote_sdp_port) {
- if (!strcmp(v_engine->codec_params.remote_sdp_ip, rip) && atoi(rvp) == v_engine->codec_params.remote_sdp_port) {
+ if (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->codec_params.remote_sdp_ip, v_engine->codec_params.remote_sdp_port);
+ 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_set_remote_address(v_engine->rtp_session, v_engine->codec_params.remote_sdp_ip,
- v_engine->codec_params.remote_sdp_port, remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
+ 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->codec_params.remote_sdp_ip, v_engine->codec_params.remote_sdp_port);
+ 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_PROXY_MODE) &&
!((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
!switch_channel_test_flag(session->channel, CF_WEBRTC)) {
start_video_thread(session);
}
- if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING) || switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_PT)) {
+ if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING)) {
v_engine->check_frames = 0;
}
}
const char *rport = NULL;
switch_port_t remote_rtcp_port = 0;
- if (remote_host && remote_port && !strcmp(remote_host, a_engine->codec_params.remote_sdp_ip) && remote_port == a_engine->codec_params.remote_sdp_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, "Remote address:port [%s:%d] has not changed.\n",
- a_engine->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
switch_goto_status(SWITCH_STATUS_BREAK, end);
}
}
- if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port, remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
+ 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->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ 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_WEBRTC)) {
/* 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) || switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_PT)) {
+ if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING)) {
a_engine->check_frames = 0;
}
status = SWITCH_STATUS_SUCCESS;
/* 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->codec_params.adv_sdp_port) {
+ switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) || engine->adv_sdp_port) {
return SWITCH_STATUS_SUCCESS;
}
}
/* Release the local sdp port */
- if (engine->codec_params.local_sdp_port) {
- switch_rtp_release_port(smh->mparams->rtpip, engine->codec_params.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->codec_params.local_sdp_port = switch_rtp_request_port(smh->mparams->rtpip))) {
+ 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->codec_params.local_sdp_ip = smh->mparams->rtpip;
+ engine->local_sdp_ip = smh->mparams->rtpip;
- sdp_port = engine->codec_params.local_sdp_port;
+ 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->codec_params.local_sdp_port, SWITCH_NAT_UDP, &sdp_port, SWITCH_FALSE);
+ 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);
use_ip = smh->mparams->rtpip;
}
- engine->codec_params.adv_sdp_port = sdp_port;
- engine->codec_params.adv_sdp_ip = smh->mparams->adv_sdp_audio_ip = smh->mparams->extrtpip = switch_core_session_strdup(session, use_ip);
+ 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->codec_params.local_sdp_ip);
+ 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->codec_params.adv_sdp_ip);
+ switch_channel_set_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE, engine->adv_sdp_ip);
} else {
- switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE, engine->codec_params.adv_sdp_ip);
+ 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);
}
if (v_engine->rtp_session) {
switch_rtp_destroy(&v_engine->rtp_session);
- } else if (v_engine->codec_params.local_sdp_port) {
- switch_rtp_release_port(smh->mparams->rtpip, v_engine->codec_params.local_sdp_port);
+ } else if (v_engine->local_sdp_port) {
+ switch_rtp_release_port(smh->mparams->rtpip, v_engine->local_sdp_port);
}
- if (v_engine->codec_params.local_sdp_port > 0 && !zstr(smh->mparams->remote_ip) &&
+ 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->codec_params.local_sdp_port, SWITCH_NAT_UDP);
- switch_nat_del_mapping((switch_port_t) v_engine->codec_params.local_sdp_port + 1, SWITCH_NAT_UDP);
+ 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 (a_engine->rtp_session) {
switch_rtp_destroy(&a_engine->rtp_session);
- } else if (a_engine->codec_params.local_sdp_port) {
- switch_rtp_release_port(smh->mparams->rtpip, a_engine->codec_params.local_sdp_port);
+ } else if (a_engine->local_sdp_port) {
+ switch_rtp_release_port(smh->mparams->rtpip, a_engine->local_sdp_port);
}
- if (a_engine->codec_params.local_sdp_port > 0 && !zstr(smh->mparams->remote_ip) &&
+ 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->codec_params.local_sdp_port, SWITCH_NAT_UDP);
- switch_nat_del_mapping((switch_port_t) a_engine->codec_params.local_sdp_port + 1, SWITCH_NAT_UDP);
+ 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);
}
}
switch_media_handle_t *smh;
switch_assert(session);
-
+
if (!(smh = session->media_handle)) {
return SWITCH_STATUS_FALSE;
}
goto end;
}
+ switch_core_media_set_video_codec(session, 0);
+
+
memset(flags, 0, sizeof(flags));
flags[SWITCH_RTP_FLAG_DATAWAIT]++;
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->codec_params.remote_sdp_ip) && remote_port == a_engine->codec_params.remote_sdp_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));
- if (switch_rtp_ready(a_engine->rtp_session)) {
- if (a_engine->codec_params.recv_pt != a_engine->codec_params.agreed_pt) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Set audio receive payload in Re-INVITE for non-matching dynamic PT to %u\n",
- switch_channel_get_name(session->channel), a_engine->codec_params.recv_pt);
-
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->codec_params.recv_pt);
- } else {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Setting audio receive payload in Re-INVITE to %u\n",
- switch_channel_get_name(session->channel), a_engine->codec_params.recv_pt);
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->codec_params.agreed_pt);
- }
-
- }
+ //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->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ 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->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->codec_params.remote_sdp_ip);
+ 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_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->codec_params.local_sdp_ip,
- a_engine->codec_params.local_sdp_port,
- a_engine->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port, a_engine->codec_params.agreed_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->codec_params.agreed_pt);
-
- if (a_engine->codec_params.recv_pt != a_engine->codec_params.agreed_pt) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Set audio receive payload to %u\n", switch_channel_get_name(session->channel), a_engine->codec_params.recv_pt);
-
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->codec_params.recv_pt);
- } else {
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->codec_params.agreed_pt);
- }
+ 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->agreed_pt, a_engine->read_impl.microseconds_per_packet / 1000);
- }
+ //XX
}
- switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->codec_params.local_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE, a_engine->codec_params.local_sdp_ip);
+ 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->codec_params.adv_sdp_ip);
+ switch_channel_set_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE, a_engine->adv_sdp_ip);
if (a_engine->rtp_session && switch_channel_test_flag(session->channel, CF_REINVITE)) {
const char *rport = NULL;
}
}
- if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port,
+ 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->codec_params.remote_sdp_ip, a_engine->codec_params.remote_sdp_port);
+ 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->codec_params.remote_sdp_ip, "0.0.0.0")) {
+ 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);
}
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->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port,
- a_engine->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port, a_engine->codec_params.agreed_pt, a_engine->read_impl.microseconds_per_packet / 1000);
+ 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->agreed_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->codec_params.agreed_pt);
+ switch_rtp_set_default_payload(a_engine->rtp_session, a_engine->cur_payload_map->agreed_pt);
}
} else {
}
if (switch_channel_up(session->channel)) {
- a_engine->rtp_session = switch_rtp_new(a_engine->codec_params.local_sdp_ip,
- a_engine->codec_params.local_sdp_port,
- a_engine->codec_params.remote_sdp_ip,
- a_engine->codec_params.remote_sdp_port,
- a_engine->codec_params.agreed_pt,
+
+ 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->agreed_pt,
a_engine->read_impl.samples_per_packet,
- a_engine->codec_params.codec_ms * 1000,
+ a_engine->cur_payload_map->codec_ms * 1000,
flags, timer_name, &err, switch_core_session_get_pool(session));
+
+ 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)) {
switch_channel_set_flag(session->channel, CF_FS_RTP);
- switch_channel_set_variable_printf(session->channel, "rtp_use_pt", "%d", a_engine->codec_params.agreed_pt);
+ switch_channel_set_variable_printf(session->channel, "rtp_use_pt", "%d", a_engine->cur_payload_map->agreed_pt);
if ((val = switch_channel_get_variable(session->channel, "rtp_enable_vad_in")) && switch_true(val)) {
vad_in = 1;
switch_channel_set_variable_printf(session->channel, "rtp_2833_recv_payload", "%d", smh->mparams->recv_te);
}
- if (a_engine->codec_params.recv_pt != a_engine->codec_params.agreed_pt) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Set audio receive payload to %u\n", switch_channel_get_name(session->channel), a_engine->codec_params.recv_pt);
-
- switch_rtp_set_recv_pt(a_engine->rtp_session, a_engine->codec_params.recv_pt);
- }
+ //XX
if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) ||
((val = switch_channel_get_variable(session->channel, "supress_cng")) && switch_true(val)) ||
switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_AUDIO);
- switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->codec_params.remote_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->codec_params.remote_sdp_ip);
+ 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_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->codec_params.rm_encoding && v_engine->codec_params.remote_sdp_port) {
+
+ 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 && switch_channel_test_flag(session->channel, CF_REINVITE)) {
//const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
- if (remote_host && remote_port && !strcmp(remote_host, v_engine->codec_params.remote_sdp_ip) && remote_port == v_engine->codec_params.remote_sdp_port) {
+ 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));
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->codec_params.remote_sdp_ip, v_engine->codec_params.remote_sdp_port);
+ remote_host, remote_port, v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
}
}
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 ms: %d\n", switch_channel_get_name(session->channel),
- a_engine->codec_params.remote_sdp_ip, v_engine->codec_params.local_sdp_port, v_engine->codec_params.remote_sdp_ip,
- v_engine->codec_params.remote_sdp_port, v_engine->codec_params.agreed_pt,
+ 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->agreed_pt,
a_engine->read_impl.microseconds_per_packet / 1000);
start_video_thread(session);
- switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->codec_params.agreed_pt);
+ switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
}
}
- switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->codec_params.local_sdp_port);
- switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE, a_engine->codec_params.adv_sdp_ip);
+ 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 (switch_rtp_set_remote_address
- (v_engine->rtp_session, v_engine->codec_params.remote_sdp_ip, v_engine->codec_params.remote_sdp_port, remote_rtcp_port, SWITCH_TRUE,
+ (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->codec_params.remote_sdp_ip, v_engine->codec_params.remote_sdp_port);
+ 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_WEBRTC) &&
!((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
/* Reactivate the NAT buster flag. */
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->codec_params.remote_sdp_ip,
- v_engine->codec_params.local_sdp_port,
- v_engine->codec_params.remote_sdp_ip,
- v_engine->codec_params.remote_sdp_port, v_engine->codec_params.agreed_pt, v_engine->read_impl.microseconds_per_packet / 1000);
+ 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->agreed_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->codec_params.agreed_pt);
+ switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
}
} else {
timer_name = smh->mparams->timer_name;
}
- if (!v_engine->codec_params.local_sdp_port) {
+ if (!v_engine->local_sdp_port) {
switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
}
flags[SWITCH_RTP_FLAG_NOBLOCK] = 0;
flags[SWITCH_RTP_FLAG_VIDEO]++;
- v_engine->rtp_session = switch_rtp_new(a_engine->codec_params.local_sdp_ip,
- v_engine->codec_params.local_sdp_port,
- v_engine->codec_params.remote_sdp_ip,
- v_engine->codec_params.remote_sdp_port,
- v_engine->codec_params.agreed_pt,
+ 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->agreed_pt,
1, 90000, flags, NULL, &err, switch_core_session_get_pool(session));
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->codec_params.remote_sdp_ip,
- v_engine->codec_params.local_sdp_port,
- v_engine->codec_params.remote_sdp_ip,
- v_engine->codec_params.remote_sdp_port, v_engine->codec_params.agreed_pt,
+ 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->agreed_pt,
0, switch_rtp_ready(v_engine->rtp_session) ? "SUCCESS" : err);
- if (switch_rtp_ready(v_engine->rtp_session)) {
- start_video_thread(session);
- }
-
if (switch_rtp_ready(v_engine->rtp_session)) {
const char *ssrc;
+
+ switch_rtp_set_payload_map(v_engine->rtp_session, &v_engine->payload_map);
+
+ start_video_thread(session);
switch_channel_set_flag(session->channel, CF_VIDEO);
+
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);
switch_rtp_intentional_bugs(v_engine->rtp_session, v_engine->rtp_bugs | smh->mparams->manual_video_rtp_bugs);
- if (v_engine->codec_params.recv_pt != v_engine->codec_params.agreed_pt) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s Set video receive payload to %u\n", switch_channel_get_name(session->channel), v_engine->codec_params.recv_pt);
- switch_rtp_set_recv_pt(v_engine->rtp_session, v_engine->codec_params.recv_pt);
- }
+
+ //XX
- switch_channel_set_variable_printf(session->channel, "rtp_use_video_pt", "%d", v_engine->codec_params.agreed_pt);
+
+ switch_channel_set_variable_printf(session->channel, "rtp_use_video_pt", "%d", v_engine->cur_payload_map->agreed_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);
//?
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)
+ 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;
fmtp = check;
}
}
-
+
if (smh->ianacodes[i] > 95 || switch_channel_test_flag(session->channel, CF_VERBOSE_SDP)) {
int channels = get_channels(imp->iananame, imp->number_of_channels);
ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
);
- if (!zstr(a_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
- strcmp(a_engine->codec_params.local_sdp_ip, ice_out->cands[0][0].con_addr)
- && a_engine->codec_params.local_sdp_port != 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\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->codec_params.local_sdp_ip, a_engine->codec_params.local_sdp_port
+ a_engine->local_sdp_ip, a_engine->local_sdp_port
);
}
ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
);
- if (!zstr(a_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) &&
- strcmp(a_engine->codec_params.local_sdp_ip, ice_out->cands[0][1].con_addr)
- && a_engine->codec_params.local_sdp_port != ice_out->cands[0][1].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\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->codec_params.local_sdp_ip, a_engine->codec_params.local_sdp_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)
);
}
}
//?
#define SDPBUFLEN 65536
-SWITCH_DECLARE(void) switch_core_media_gen_local_sdp(switch_core_session_t *session, const char *ip, switch_port_t port, const char *sr, int force)
+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;
switch_media_handle_t *smh;
ice_t *ice_out;
int vp8 = 0;
+ payload_map_t *pmap;
switch_assert(session);
}
}
- fmtp_out = a_engine->codec_params.fmtp_out;
+ fmtp_out = a_engine->cur_payload_map->fmtp_out;
username = smh->mparams->sdp_username;
smh->mparams->cng_pt = 0;
}
+
if (!smh->payload_space) {
int i;
smh->payload_space = 98;
- for (i = 0; i < smh->mparams->num_codecs; i++) {
- const switch_codec_implementation_t *imp = smh->codecs[i];
-
- smh->ianacodes[i] = imp->ianacode;
-
- 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 (sdp_type == SDP_TYPE_REQUEST) {
+ for (i = 0; i < smh->mparams->num_codecs; i++) {
+ const switch_codec_implementation_t *imp = smh->codecs[i];
+
+ smh->ianacodes[i] = imp->ianacode;
+
+ 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++;
+ }
+ smh->ianacodes[i] = (switch_payload_t)smh->payload_space++;
}
- 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,
+ sdp_type,
+ smh->ianacodes[i],
+ imp->samples_per_second,
+ imp->microseconds_per_packet / 1000,
+ SWITCH_FALSE);
}
+
}
}
}
if (!ip) {
- if (!(ip = a_engine->codec_params.adv_sdp_ip)) {
- ip = a_engine->codec_params.proxy_sdp_ip;
+ if (!(ip = a_engine->adv_sdp_ip)) {
+ ip = a_engine->proxy_sdp_ip;
}
}
}
if (!port) {
- if (!(port = a_engine->codec_params.adv_sdp_port)) {
- port = a_engine->codec_params.proxy_sdp_port;
+ if (!(port = a_engine->adv_sdp_port)) {
+ port = a_engine->proxy_sdp_port;
}
}
return;
}
- if (!a_engine->codec_params.rm_encoding && (b_sdp = switch_channel_get_variable(session->channel, SWITCH_B_SDP_VARIABLE))) {
+ 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);
}
}
- if (a_engine->codec_params.rm_encoding) {
+ if (a_engine->codec_negotiated) {
/*
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=audio %d RTP/%sAVP%s",
port, ((!zstr(local_audio_crypto_key) || switch_channel_test_flag(session->channel, CF_DTLS)) &&
));
- switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", a_engine->codec_params.pt);
+ 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->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->mutex);
+ }
if ((smh->mparams->dtmf_type == DTMF_2833 || switch_media_handle_test_media_flag(smh, SCMF_LIBERAL_DTMF) ||
switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF)) && smh->mparams->te > 95) {
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "\n");
- rate = a_engine->codec_params.adv_rm_rate;
+ rate = a_engine->cur_payload_map->adv_rm_rate;
- if (!a_engine->codec_params.adv_channels) {
- a_engine->codec_params.adv_channels = get_channels(a_engine->codec_params.rm_encoding, 1);
+ 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->codec_params.adv_channels > 1) {
+
+ if (a_engine->cur_payload_map->adv_channels > 1) {
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%d/%d\n",
- a_engine->codec_params.agreed_pt, a_engine->codec_params.rm_encoding, rate, a_engine->codec_params.adv_channels);
+ a_engine->cur_payload_map->agreed_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\n",
- a_engine->codec_params.agreed_pt, a_engine->codec_params.rm_encoding, rate);
+ a_engine->cur_payload_map->agreed_pt, a_engine->cur_payload_map->rm_encoding, rate);
}
if (fmtp_out) {
- switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\n", a_engine->codec_params.agreed_pt, fmtp_out);
+ switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\n", a_engine->cur_payload_map->agreed_pt, fmtp_out);
+ }
+
+ if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_AUDIO)) {
+ switch_mutex_lock(smh->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\n",
+ pmap->pt, pmap->iananame,
+ pmap->rate);
+ }
+ }
+ switch_mutex_unlock(smh->mutex);
}
+
if (a_engine->read_codec.implementation && !ptime) {
ptime = a_engine->read_codec.implementation->microseconds_per_packet / 1000;
}
} else if (smh->mparams->cng_pt && use_cng) {
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d CN/8000\n", smh->mparams->cng_pt);
- if (!a_engine->codec_params.rm_encoding) {
+ if (!a_engine->codec_negotiated) {
smh->mparams->cng_pt = 0;
}
}
ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
);
- if (!zstr(a_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
- strcmp(a_engine->codec_params.local_sdp_ip, ice_out->cands[0][0].con_addr)
- && a_engine->codec_params.local_sdp_port != 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\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->codec_params.local_sdp_ip, a_engine->codec_params.local_sdp_port
+ a_engine->local_sdp_ip, a_engine->local_sdp_port
);
}
- if (!zstr(a_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
- strcmp(a_engine->codec_params.local_sdp_ip, ice_out->cands[0][0].con_addr)
- && a_engine->codec_params.local_sdp_port != 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 2 %s %u %s %d typ srflx raddr %s rport %d generation 0\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->codec_params.local_sdp_ip, a_engine->codec_params.local_sdp_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)
);
}
}
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_params.rm_encoding) {
+ if (!a_engine->codec_negotiated) {
smh->mparams->cng_pt = 0;
}
}
if ((!zstr(local_audio_crypto_key) && 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);
+ generate_m(session, buf, SDPBUFLEN, port, family, ip, 0, append_audio, sr, use_cng, cng_type, map, 1, sdp_type);
bp = (buf + strlen(buf));
/* asterisk can't handle AVP and SAVP in sep streams, way to blow off the spec....*/
}
if (both) {
- generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, 0, append_audio, sr, use_cng, cng_type, map, 0);
+ generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, 0, append_audio, sr, use_cng, cng_type, map, 0, sdp_type);
}
} else {
if ((!zstr(local_audio_crypto_key) && 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);
+ 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));
/* asterisk can't handle AVP and SAVP in sep streams, way to blow off the spec....*/
}
if (both) {
- generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, cur_ptime, append_audio, sr, use_cng, cng_type, map, 0);
+ generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, cur_ptime, append_audio, sr, use_cng, cng_type, map, 0, sdp_type);
}
}
}
- if (!v_engine->codec_params.local_sdp_port) {
+ if (!v_engine->local_sdp_port) {
switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 0);
}
- if ((v_port = v_engine->codec_params.adv_sdp_port)) {
+ if (switch_channel_test_flag(session->channel, CF_WEBRTC)) {
+ switch_media_handle_set_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO);
+ }
+
+ if ((v_port = v_engine->adv_sdp_port)) {
if (switch_channel_test_flag(smh->session->channel, CF_ICE)) {
gen_ice(session, SWITCH_MEDIA_TYPE_VIDEO, ip, (switch_port_t)v_port);
/*****************************/
- if (v_engine->codec_params.rm_encoding) {
+ 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->codec_params.agreed_pt);
+ switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", v_engine->cur_payload_map->agreed_pt);
+
+ if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO)) {
+ switch_mutex_lock(smh->mutex);
+ for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
+ if (pmap->pt != v_engine->cur_payload_map->pt) {
+ switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", pmap->pt);
+ }
+ }
+ switch_mutex_unlock(smh->mutex);
+ }
+
} else if (smh->mparams->num_codecs) {
int i;
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;
}
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", smh->ianacodes[i]);
+
if (!ptime) {
ptime = imp->microseconds_per_packet / 1000;
}
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "\n");
- if (v_engine->codec_params.rm_encoding) {
+ if (v_engine->codec_negotiated) {
const char *of;
+ payload_map_t *pmap;
- if (!strcasecmp(v_engine->codec_params.rm_encoding, "VP8")) {
- vp8 = v_engine->codec_params.pt;
+ if (!strcasecmp(v_engine->cur_payload_map->rm_encoding, "VP8")) {
+ vp8 = v_engine->cur_payload_map->pt;
}
- rate = v_engine->codec_params.rm_rate;
+ rate = v_engine->cur_payload_map->rm_rate;
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\n",
- v_engine->codec_params.pt, v_engine->codec_params.rm_encoding,
- v_engine->codec_params.rm_rate);
+ 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->codec_params.rm_fmtp;
+ pass_fmtp = v_engine->cur_payload_map->rm_fmtp;
} else {
pass_fmtp = NULL;
}
if (pass_fmtp) {
- switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\n", v_engine->codec_params.pt, pass_fmtp);
+ switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\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->mutex);
+ for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
+ if (pmap->pt != v_engine->cur_payload_map->pt) {
+ switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\n",
+ pmap->pt, pmap->iananame, pmap->rate);
+
+ }
+ }
+ switch_mutex_unlock(smh->mutex);
}
+
if (append_video) {
switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s%s", append_video, end_of(append_video) == '\n' ? "" : "\n");
}
ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
);
- if (!zstr(v_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
- strcmp(v_engine->codec_params.local_sdp_ip, ice_out->cands[0][0].con_addr)
- && v_engine->codec_params.local_sdp_port != 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\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->codec_params.local_sdp_ip, v_engine->codec_params.local_sdp_port
+ v_engine->local_sdp_ip, v_engine->local_sdp_port
);
}
);
- if (!zstr(v_engine->codec_params.local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) &&
- strcmp(v_engine->codec_params.local_sdp_ip, ice_out->cands[0][1].con_addr)
- && v_engine->codec_params.local_sdp_port != ice_out->cands[0][1].con_port) {
+ 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\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->codec_params.local_sdp_ip, v_engine->codec_params.local_sdp_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)
);
}
}
}
if (connection) {
- a_engine->codec_params.proxy_sdp_ip = switch_core_session_strdup(session, connection->c_address);
+ a_engine->proxy_sdp_ip = switch_core_session_strdup(session, connection->c_address);
}
- a_engine->codec_params.proxy_sdp_port = (switch_port_t) m->m_port;
- if (a_engine->codec_params.proxy_sdp_ip && a_engine->codec_params.proxy_sdp_port) {
+ a_engine->proxy_sdp_port = (switch_port_t) m->m_port;
+ if (a_engine->proxy_sdp_ip && a_engine->proxy_sdp_port) {
break;
}
}
if (!ip) {
- if (!(ip = a_engine->codec_params.adv_sdp_ip)) {
- ip = a_engine->codec_params.proxy_sdp_ip;
+ if (!(ip = a_engine->adv_sdp_ip)) {
+ ip = a_engine->proxy_sdp_ip;
}
}
}
if (!port) {
- if (!(port = a_engine->codec_params.adv_sdp_port)) {
- port = a_engine->codec_params.proxy_sdp_port;
+ if (!(port = a_engine->adv_sdp_port)) {
+ port = a_engine->proxy_sdp_port;
}
}
return;
}
- if (zstr(a_engine->codec_params.local_sdp_ip) || !a_engine->codec_params.local_sdp_port) {// || switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
+ 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;
}
- a_engine->codec_params.iananame = switch_core_session_strdup(session, "PROXY");
- a_engine->codec_params.rm_rate = 8000;
- a_engine->codec_params.adv_rm_rate = 8000;
- a_engine->codec_params.codec_ms = 20;
+ a_engine->cur_payload_map->iananame = switch_core_session_strdup(session, "PROXY");
+ a_engine->cur_payload_map->rm_rate = 8000;
+ a_engine->cur_payload_map->adv_rm_rate = 8000;
+ a_engine->cur_payload_map->codec_ms = 20;
}
new_sdp = switch_core_session_alloc(session, len);
- switch_snprintf(port_buf, sizeof(port_buf), "%u", a_engine->codec_params.local_sdp_port);
+ switch_snprintf(port_buf, sizeof(port_buf), "%u", a_engine->local_sdp_port);
p = smh->mparams->local_sdp_str;
goto end;
}
- if (a_engine->codec_params.local_sdp_ip && !strncmp("c=IN IP", p, 7)) {
+ if (a_engine->local_sdp_ip && !strncmp("c=IN IP", p, 7)) {
strncpy(q, p, 7);
p += 7;
q += 7;
- strncpy(q, strchr(a_engine->codec_params.adv_sdp_ip, ':') ? "6 " : "4 ", 2);
+ strncpy(q, strchr(a_engine->adv_sdp_ip, ':') ? "6 " : "4 ", 2);
p +=2;
q +=2;
- strncpy(q, a_engine->codec_params.adv_sdp_ip, strlen(a_engine->codec_params.adv_sdp_ip));
- q += strlen(a_engine->codec_params.adv_sdp_ip);
+ strncpy(q, a_engine->adv_sdp_ip, strlen(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) {
} else if (!strncmp("m=video ", p, 8) && *(p + 8) != '0') {
if (!has_video) {
switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
- v_engine->codec_params.rm_encoding = "PROXY-VID";
- v_engine->codec_params.rm_rate = 90000;
- v_engine->codec_params.adv_rm_rate = 90000;
- v_engine->codec_params.codec_ms = 0;
- switch_snprintf(vport_buf, sizeof(vport_buf), "%u", v_engine->codec_params.adv_sdp_port);
+ v_engine->cur_payload_map->rm_encoding = "PROXY-VID";
+ v_engine->cur_payload_map->rm_rate = 90000;
+ v_engine->cur_payload_map->adv_rm_rate = 90000;
+ v_engine->cur_payload_map->codec_ms = 0;
+ 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);
const char *ip = NULL, *port = NULL;
switch_channel_set_flag(session->channel, CF_PROXY_MODE);
- if (a_engine->codec_params.rm_encoding) {
- a_engine->codec_params.rm_encoding = NULL;
- }
+
+ a_engine->codec_negotiated = 0;
+
switch_core_media_set_local_sdp(session, NULL, SWITCH_FALSE);
if (switch_true(switch_channel_get_variable(session->channel, "bypass_keep_codec"))) {
port = switch_channel_get_variable(other_channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE);
switch_core_session_rwunlock(other_session);
if (ip && port) {
- switch_core_media_gen_local_sdp(session, ip, (switch_port_t)atoi(port), NULL, 1);
+ switch_core_media_gen_local_sdp(session, SDP_TYPE_REQUEST, ip, (switch_port_t)atoi(port), NULL, 1);
}
}
switch_channel_set_variable(session->channel, "codec_string", msg->string_arg);
} else {
switch_channel_set_variable_printf(session->channel, "codec_string", "=%s%s%s,%s",
- v_engine->codec_params.rm_encoding ? v_engine->codec_params.rm_encoding : "",
- v_engine->codec_params.rm_encoding ? "," : "",
- a_engine->codec_params.rm_encoding, msg->string_arg);
+ v_engine->cur_payload_map->rm_encoding ? v_engine->cur_payload_map->rm_encoding : "",
+ v_engine->cur_payload_map->rm_encoding ? "," : "",
+ a_engine->cur_payload_map->rm_encoding, msg->string_arg);
}
-
- a_engine->codec_params.rm_encoding = NULL;
- v_engine->codec_params.rm_encoding = NULL;
+ a_engine->codec_negotiated = 0;
+ v_engine->codec_negotiated = 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, NULL, 0, NULL, 1);
+ switch_core_media_gen_local_sdp(session, SDP_TYPE_REQUEST, NULL, 0, NULL, 1);
}
switch_media_handle_set_media_flag(smh, SCMF_RENEG_ON_REINVITE);
}
}
-//?
-SWITCH_DECLARE(void) switch_core_media_set_recv_pt(switch_core_session_t *session, switch_media_type_t type, switch_payload_t pt)
-{
- 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_recv_pt(smh->engines[type].rtp_session, pt);
- }
-}
-
//?
SWITCH_DECLARE(void) switch_core_media_set_telephony_event(switch_core_session_t *session, switch_media_type_t type, switch_payload_t te)
{
engine = &smh->engines[type];
- if (engine->codec_params.iananame) {
+ if (engine->cur_payload_map->iananame) {
return SWITCH_STATUS_SUCCESS;
}
switch_channel_set_flag(session->channel, CF_PROXY_MEDIA);
- a_engine->codec_params.iananame = switch_core_session_strdup(session, "PROXY");
- a_engine->codec_params.rm_rate = 8000;
- a_engine->codec_params.adv_rm_rate = 8000;
+ a_engine->cur_payload_map->iananame = switch_core_session_strdup(session, "PROXY");
+ a_engine->cur_payload_map->rm_rate = 8000;
+ a_engine->cur_payload_map->adv_rm_rate = 8000;
- a_engine->codec_params.codec_ms = 20;
+ a_engine->cur_payload_map->codec_ms = 20;
if (switch_stristr("m=video", r_sdp)) {
switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
- v_engine->codec_params.rm_encoding = "PROXY-VID";
- v_engine->codec_params.rm_rate = 90000;
- v_engine->codec_params.adv_rm_rate = 90000;
- v_engine->codec_params.codec_ms = 0;
+ v_engine->cur_payload_map->rm_encoding = "PROXY-VID";
+ v_engine->cur_payload_map->rm_rate = 90000;
+ v_engine->cur_payload_map->adv_rm_rate = 90000;
+ v_engine->cur_payload_map->codec_ms = 0;
switch_channel_set_flag(session->channel, CF_VIDEO);
switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
}
}
for (map = m->m_rtpmaps; map; map = map->rm_next) {
- a_engine->codec_params.iananame = switch_core_session_strdup(session, map->rm_encoding);
- a_engine->codec_params.rm_rate = map->rm_rate;
- a_engine->codec_params.adv_rm_rate = map->rm_rate;
- a_engine->codec_params.codec_ms = ptime;
+ a_engine->cur_payload_map->iananame = switch_core_session_strdup(session, map->rm_encoding);
+ a_engine->cur_payload_map->rm_rate = map->rm_rate;
+ a_engine->cur_payload_map->adv_rm_rate = map->rm_rate;
+ a_engine->cur_payload_map->codec_ms = ptime;
switch_core_media_set_codec(session, 0, smh->mparams->codec_flags);
break;
}
a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
-
- a_engine->codec_params.iananame = a_engine->codec_params.rm_encoding = (char *) switch_channel_get_variable(session->channel, "rtp_use_codec_name");
- a_engine->codec_params.rm_fmtp = (char *) switch_channel_get_variable(session->channel, "rtp_use_codec_fmtp");
+ 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_codec_rate"))) {
- a_engine->codec_params.rm_rate = atoi(tmp);
- a_engine->codec_params.adv_rm_rate = a_engine->codec_params.rm_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->codec_params.codec_ms = atoi(tmp);
+ a_engine->cur_payload_map->codec_ms = atoi(tmp);
}
if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_pt"))) {
- a_engine->codec_params.pt = a_engine->codec_params.agreed_pt = (switch_payload_t)atoi(tmp);
+ a_engine->cur_payload_map->pt = a_engine->cur_payload_map->agreed_pt = (switch_payload_t)atoi(tmp);
}
if ((tmp = switch_channel_get_variable(session->channel, "rtp_audio_recv_pt"))) {
- a_engine->codec_params.recv_pt = a_engine->codec_params.agreed_pt = (switch_payload_t)atoi(tmp);;
+ a_engine->cur_payload_map->recv_pt = (switch_payload_t)atoi(tmp);
}
switch_core_media_set_codec(session, 1, smh->mparams->codec_flags);
- a_engine->codec_params.adv_sdp_ip = smh->mparams->extrtpip = (char *) ip;
- a_engine->codec_params.adv_sdp_port = a_engine->codec_params.local_sdp_port = (switch_port_t)atoi(port);
+ 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);
if (!zstr(ip)) {
- a_engine->codec_params.local_sdp_ip = switch_core_session_strdup(session, ip);
- smh->mparams->rtpip = a_engine->codec_params.local_sdp_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->codec_params.adv_sdp_ip = switch_core_session_strdup(session, a_ip);
+ a_engine->adv_sdp_ip = switch_core_session_strdup(session, a_ip);
}
if (r_ip && r_port) {
- a_engine->codec_params.remote_sdp_ip = (char *) r_ip;
- a_engine->codec_params.remote_sdp_port = (switch_port_t)atoi(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->codec_params.pt = v_engine->codec_params.agreed_pt = (switch_payload_t)atoi(tmp);
+ v_engine->cur_payload_map->pt = v_engine->cur_payload_map->agreed_pt = (switch_payload_t)atoi(tmp);
}
if ((tmp = switch_channel_get_variable(session->channel, "rtp_video_recv_pt"))) {
- v_engine->codec_params.recv_pt = a_engine->codec_params.agreed_pt = (switch_payload_t)atoi(tmp);;
+ v_engine->cur_payload_map->recv_pt = (switch_payload_t)atoi(tmp);;
}
- v_engine->codec_params.rm_encoding = (char *) switch_channel_get_variable(session->channel, "rtp_use_video_codec_name");
- v_engine->codec_params.rm_fmtp = (char *) switch_channel_get_variable(session->channel, "rtp_use_video_codec_fmtp");
+ 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");
ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE);
port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_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->codec_params.rm_rate = atoi(tmp);
- v_engine->codec_params.adv_rm_rate = v_engine->codec_params.rm_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->codec_params.codec_ms = atoi(tmp);
+ v_engine->cur_payload_map->codec_ms = atoi(tmp);
}
- v_engine->codec_params.adv_sdp_port = v_engine->codec_params.local_sdp_port = (switch_port_t)atoi(port);
+ v_engine->adv_sdp_port = v_engine->local_sdp_port = (switch_port_t)atoi(port);
if (r_ip && r_port) {
- v_engine->codec_params.remote_sdp_ip = (char *) r_ip;
- v_engine->codec_params.remote_sdp_port = (switch_port_t)atoi(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, NULL, 0, NULL, 1);
+ switch_core_media_gen_local_sdp(session, SDP_TYPE_REQUEST, NULL, 0, NULL, 1);
+ switch_core_media_set_video_codec(session, 1);
if (switch_core_media_activate_rtp(session) != SWITCH_STATUS_SUCCESS) {
return;
if (switch_core_media_ready(session, SWITCH_MEDIA_TYPE_AUDIO)) {
- switch_core_media_set_recv_pt(session, SWITCH_MEDIA_TYPE_AUDIO, a_engine->codec_params.recv_pt);
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);
}
- if (switch_core_media_ready(session, SWITCH_MEDIA_TYPE_VIDEO)) {
- switch_core_media_set_recv_pt(session, SWITCH_MEDIA_TYPE_VIDEO, v_engine->codec_params.recv_pt);
- }
-
}
projects / thirdparty / freeswitch.git / commitdiff
