Skip to content

F
freeswitch
提交 e9d7a4a4 authored 作者: Anthony Minessale's avatar Anthony Minessale
浏览文件
操作

adjustment 

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@10876 d0543943-73ff-0310-b7d9-9358b9ac24b2
上级 61647d0f
隐藏空白字符变更
内嵌 并排
正在显示 包含 365 行增加 和 312 行删除
src/include/switch_core.h
浏览文件 @ e9d7a4a4
...@@ -1165,6 +1165,12 @@ SWITCH_DECLARE(void) switch_core_session_unset_read_codec(_In_ switch_core_sessi ...@@ -1165,6 +1165,12 @@ SWITCH_DECLARE(void) switch_core_session_unset_read_codec(_In_ switch_core_sessi
SWITCH_DECLARE(void) switch_core_session_unset_write_codec(_In_ switch_core_session_t *session); SWITCH_DECLARE(void) switch_core_session_unset_write_codec(_In_ switch_core_session_t *session);
SWITCH_DECLARE(void) switch_core_session_lock_codec_write(_In_ switch_core_session_t *session);
SWITCH_DECLARE(void) switch_core_session_unlock_codec_write(_In_ switch_core_session_t *session);
SWITCH_DECLARE(void) switch_core_session_lock_codec_read(_In_ switch_core_session_t *session);
SWITCH_DECLARE(void) switch_core_session_unlock_codec_read(_In_ switch_core_session_t *session);
SWITCH_DECLARE(switch_status_t) switch_core_session_get_read_impl(switch_core_session_t *session, switch_codec_implementation_t *impp); SWITCH_DECLARE(switch_status_t) switch_core_session_get_read_impl(switch_core_session_t *session, switch_codec_implementation_t *impp);
SWITCH_DECLARE(switch_status_t) switch_core_session_get_write_impl(switch_core_session_t *session, switch_codec_implementation_t *impp); SWITCH_DECLARE(switch_status_t) switch_core_session_get_write_impl(switch_core_session_t *session, switch_codec_implementation_t *impp);
SWITCH_DECLARE(switch_status_t) switch_core_session_get_video_read_impl(switch_core_session_t *session, switch_codec_implementation_t *impp); SWITCH_DECLARE(switch_status_t) switch_core_session_get_video_read_impl(switch_core_session_t *session, switch_codec_implementation_t *impp);
......
src/include/switch_utils.h
浏览文件 @ e9d7a4a4
...@@ -56,7 +56,7 @@ SWITCH_DECLARE(int) switch_isspace(int c); ...@@ -56,7 +56,7 @@ SWITCH_DECLARE(int) switch_isspace(int c);
SWITCH_DECLARE(int) switch_isupper(int c); SWITCH_DECLARE(int) switch_isupper(int c);
SWITCH_DECLARE(int) switch_isxdigit(int c); SWITCH_DECLARE(int) switch_isxdigit(int c);
#define switch_goto_status(_status, _label) status = _status; goto _label
#define switch_samples_per_packet(rate, interval) ((uint32_t)((float)rate / (1000.0f / (float)interval))) #define switch_samples_per_packet(rate, interval) ((uint32_t)((float)rate / (1000.0f / (float)interval)))
#define SWITCH_SMAX 32767 #define SWITCH_SMAX 32767
#define SWITCH_SMIN -32768 #define SWITCH_SMIN -32768
......
src/mod/endpoints/mod_sofia/mod_sofia.c
浏览文件 @ e9d7a4a4
...@@ -738,14 +738,20 @@ static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_f ...@@ -738,14 +738,20 @@ static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_f
tech_pvt->codec_ms = codec_ms; tech_pvt->codec_ms = codec_ms;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Changing codec ptime to %d. I bet you have a linksys/sipura =D\n", tech_pvt->codec_ms); "Changing codec ptime to %d. I bet you have a linksys/sipura =D\n", tech_pvt->codec_ms);
switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_session_lock_codec_write(session);
switch_core_session_lock_codec_read(session);
switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_codec_destroy(&tech_pvt->write_codec); switch_core_codec_destroy(&tech_pvt->write_codec);
if (sofia_glue_tech_set_codec(tech_pvt, 2) != SWITCH_STATUS_SUCCESS) { if (sofia_glue_tech_set_codec(tech_pvt, 2) != SWITCH_STATUS_SUCCESS) {
*frame = NULL; *frame = NULL;
switch_core_session_unlock_codec_write(session);
switch_core_session_unlock_codec_read(session);
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
} }
if ((val = switch_channel_get_variable(tech_pvt->channel, "rtp_timeout_sec"))) { if ((val = switch_channel_get_variable(tech_pvt->channel, "rtp_timeout_sec"))) {
int v = atoi(val); int v = atoi(val);
if (v >= 0) { if (v >= 0) {
...@@ -784,6 +790,10 @@ static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_f ...@@ -784,6 +790,10 @@ static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_f
} }
tech_pvt->check_frames = MAX_CODEC_CHECK_FRAMES; tech_pvt->check_frames = MAX_CODEC_CHECK_FRAMES;
switch_core_session_unlock_codec_write(session);
switch_core_session_unlock_codec_read(session);
} }
} }
......
src/mod/endpoints/mod_sofia/sofia_glue.c
浏览文件 @ e9d7a4a4
...@@ -1532,27 +1532,32 @@ switch_status_t sofia_glue_tech_set_video_codec(private_object_t *tech_pvt, int ...@@ -1532,27 +1532,32 @@ switch_status_t sofia_glue_tech_set_video_codec(private_object_t *tech_pvt, int
switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force) switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force)
{ {
int ms; int ms;
switch_status_t status = SWITCH_STATUS_SUCCESS;
int resetting = 0;
if (!tech_pvt->iananame) { if (!tech_pvt->iananame) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No audio codec available\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No audio codec available\n");
return SWITCH_STATUS_FALSE; switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
if (tech_pvt->read_codec.implementation) { if (tech_pvt->read_codec.implementation) {
if (!force) { if (!force) {
return SWITCH_STATUS_SUCCESS; switch_goto_status(SWITCH_STATUS_SUCCESS, end);
} }
if (strcasecmp(tech_pvt->read_codec.implementation->iananame, tech_pvt->iananame) || if (strcasecmp(tech_pvt->read_codec.implementation->iananame, tech_pvt->iananame) ||
tech_pvt->read_codec.implementation->samples_per_second != tech_pvt->rm_rate) { tech_pvt->read_codec.implementation->samples_per_second != tech_pvt->rm_rate) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Changing Codec from %s to %s\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Changing Codec from %s to %s\n",
tech_pvt->read_codec.implementation->iananame, tech_pvt->rm_encoding); tech_pvt->read_codec.implementation->iananame, tech_pvt->rm_encoding);
switch_core_session_lock_codec_write(tech_pvt->session);
switch_core_session_lock_codec_read(tech_pvt->session);
resetting = 1;
switch_core_codec_destroy(&tech_pvt->read_codec); switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_codec_destroy(&tech_pvt->write_codec); switch_core_codec_destroy(&tech_pvt->write_codec);
switch_core_session_reset(tech_pvt->session, SWITCH_TRUE); switch_core_session_reset(tech_pvt->session, SWITCH_TRUE);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Already using %s\n", tech_pvt->read_codec.implementation->iananame); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Already using %s\n", tech_pvt->read_codec.implementation->iananame);
return SWITCH_STATUS_SUCCESS; switch_goto_status(SWITCH_STATUS_SUCCESS, end);
} }
} }
...@@ -1565,7 +1570,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force) ...@@ -1565,7 +1570,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force)
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | tech_pvt->profile->codec_flags, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | tech_pvt->profile->codec_flags,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) { NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
return SWITCH_STATUS_FALSE; switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
if (switch_core_codec_init(&tech_pvt->write_codec, if (switch_core_codec_init(&tech_pvt->write_codec,
...@@ -1577,7 +1582,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force) ...@@ -1577,7 +1582,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force)
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | tech_pvt->profile->codec_flags, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | tech_pvt->profile->codec_flags,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) { NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
return SWITCH_STATUS_FALSE; switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
if (switch_rtp_ready(tech_pvt->rtp_session)) { if (switch_rtp_ready(tech_pvt->rtp_session)) {
...@@ -1590,7 +1595,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force) ...@@ -1590,7 +1595,7 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force)
if (!tech_pvt->read_codec.implementation) { if (!tech_pvt->read_codec.implementation) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
return SWITCH_STATUS_FALSE; switch_goto_status(SWITCH_STATUS_FALSE, end);
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples\n",
...@@ -1612,7 +1617,13 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force) ...@@ -1612,7 +1617,13 @@ switch_status_t sofia_glue_tech_set_codec(private_object_t *tech_pvt, int force)
switch_rtp_set_default_payload(tech_pvt->rtp_session, tech_pvt->pt); switch_rtp_set_default_payload(tech_pvt->rtp_session, tech_pvt->pt);
} }
return SWITCH_STATUS_SUCCESS; end:
if (resetting) {
switch_core_session_unlock_codec_write(tech_pvt->session);
switch_core_session_unlock_codec_read(tech_pvt->session);
}
return status;
} }
......
src/switch_core_codec.c
浏览文件 @ e9d7a4a4
...@@ -58,6 +58,26 @@ SWITCH_DECLARE(void) switch_core_session_unset_read_codec(switch_core_session_t ...@@ -58,6 +58,26 @@ SWITCH_DECLARE(void) switch_core_session_unset_read_codec(switch_core_session_t
switch_mutex_unlock(session->codec_read_mutex); switch_mutex_unlock(session->codec_read_mutex);
} }
SWITCH_DECLARE(void) switch_core_session_lock_codec_write(switch_core_session_t *session)
{
switch_mutex_lock(session->codec_write_mutex);
}
SWITCH_DECLARE(void) switch_core_session_unlock_codec_write(switch_core_session_t *session)
{
switch_mutex_unlock(session->codec_write_mutex);
}
SWITCH_DECLARE(void) switch_core_session_lock_codec_read(switch_core_session_t *session)
{
switch_mutex_lock(session->codec_read_mutex);
}
SWITCH_DECLARE(void) switch_core_session_unlock_codec_read(switch_core_session_t *session)
{
switch_mutex_unlock(session->codec_read_mutex);
}
SWITCH_DECLARE(void) switch_core_session_unset_write_codec(switch_core_session_t *session) SWITCH_DECLARE(void) switch_core_session_unset_write_codec(switch_core_session_t *session)
{ {
switch_mutex_t *mutex = NULL; switch_mutex_t *mutex = NULL;
...@@ -550,7 +570,8 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec) ...@@ -550,7 +570,8 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec)
{ {
switch_mutex_t *mutex; switch_mutex_t *mutex;
switch_memory_pool_t *pool; switch_memory_pool_t *pool;
int free_pool = 0;
switch_assert(codec != NULL); switch_assert(codec != NULL);
if (!codec->implementation) { if (!codec->implementation) {
...@@ -558,6 +579,10 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec) ...@@ -558,6 +579,10 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec)
return SWITCH_STATUS_NOT_INITALIZED; return SWITCH_STATUS_NOT_INITALIZED;
} }
if (switch_test_flag(codec, SWITCH_CODEC_FLAG_FREE_POOL)) {
free_pool = 1;
}
pool = codec->memory_pool; pool = codec->memory_pool;
mutex = codec->mutex; mutex = codec->mutex;
...@@ -571,7 +596,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec) ...@@ -571,7 +596,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec)
if (mutex) switch_mutex_unlock(mutex); if (mutex) switch_mutex_unlock(mutex);
if (switch_test_flag(codec, SWITCH_CODEC_FLAG_FREE_POOL)) { if (free_pool) {
switch_core_destroy_memory_pool(&pool); switch_core_destroy_memory_pool(&pool);
} }
......
src/switch_core_io.c
浏览文件 @ e9d7a4a4
...@@ -643,363 +643,364 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess ...@@ -643,363 +643,364 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
do_resample = TRUE; do_resample = TRUE;
} }
if (need_codec) { if (!need_codec) {
if (!switch_test_flag(session, SSF_WARN_TRANSCODE)) { do_write = TRUE;
goto done;
}
if (!switch_test_flag(session, SSF_WARN_TRANSCODE)) {
switch_core_session_message_t msg = { 0 }; switch_core_session_message_t msg = { 0 };
msg.message_id = SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY; msg.message_id = SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY;
switch_core_session_receive_message(session, &msg); switch_core_session_receive_message(session, &msg);
switch_set_flag(session, SSF_WARN_TRANSCODE); switch_set_flag(session, SSF_WARN_TRANSCODE);
} }
if (frame->codec) { if (frame->codec) {
session->raw_write_frame.datalen = session->raw_write_frame.buflen; session->raw_write_frame.datalen = session->raw_write_frame.buflen;
status = switch_core_codec_decode(frame->codec, status = switch_core_codec_decode(frame->codec,
session->write_codec, session->write_codec,
frame->data, frame->data,
frame->datalen, frame->datalen,
session->write_codec->implementation->actual_samples_per_second, session->write_codec->implementation->actual_samples_per_second,
session->raw_write_frame.data, &session->raw_write_frame.datalen, &session->raw_write_frame.rate, &flag); session->raw_write_frame.data, &session->raw_write_frame.datalen, &session->raw_write_frame.rate, &flag);
if (do_resample && status == SWITCH_STATUS_SUCCESS) { if (do_resample && status == SWITCH_STATUS_SUCCESS) {
status = SWITCH_STATUS_RESAMPLE; status = SWITCH_STATUS_RESAMPLE;
} }
switch (status) { switch (status) {
case SWITCH_STATUS_RESAMPLE: case SWITCH_STATUS_RESAMPLE:
write_frame = &session->raw_write_frame; write_frame = &session->raw_write_frame;
if (!session->write_resampler) { if (!session->write_resampler) {
switch_mutex_lock(session->resample_mutex); switch_mutex_lock(session->resample_mutex);
status = switch_resample_create(&session->write_resampler, status = switch_resample_create(&session->write_resampler,
frame->codec->implementation->actual_samples_per_second, frame->codec->implementation->actual_samples_per_second,
frame->codec->implementation->decoded_bytes_per_packet, frame->codec->implementation->decoded_bytes_per_packet,
session->write_codec->implementation->actual_samples_per_second, session->write_codec->implementation->actual_samples_per_second,
session->write_codec->implementation->decoded_bytes_per_packet, session->pool); session->write_codec->implementation->decoded_bytes_per_packet, session->pool);
switch_mutex_unlock(session->resample_mutex); switch_mutex_unlock(session->resample_mutex);
if (status != SWITCH_STATUS_SUCCESS) { if (status != SWITCH_STATUS_SUCCESS) {
goto done; goto done;
}
}
break;
case SWITCH_STATUS_SUCCESS:
session->raw_write_frame.samples = session->raw_write_frame.datalen / sizeof(int16_t);
session->raw_write_frame.timestamp = frame->timestamp;
session->raw_write_frame.rate = frame->rate;
session->raw_write_frame.m = frame->m;
session->raw_write_frame.ssrc = frame->ssrc;
session->raw_write_frame.seq = frame->seq;
session->raw_write_frame.payload = frame->payload;
write_frame = &session->raw_write_frame;
break;
case SWITCH_STATUS_BREAK:
status = SWITCH_STATUS_SUCCESS; goto error;
case SWITCH_STATUS_NOOP:
if (session->write_resampler) {
switch_mutex_lock(session->resample_mutex);
switch_resample_destroy(&session->write_resampler);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
switch_mutex_unlock(session->resample_mutex);
}
write_frame = frame;
status = SWITCH_STATUS_SUCCESS;
break;
default:
if (status == SWITCH_STATUS_NOT_INITALIZED) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
goto error;
}
if (ptime_mismatch) {
status = perform_write(session, frame, flags, stream_id);
status = SWITCH_STATUS_SUCCESS; goto error;
} }
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s decoder error!\n", frame->codec->codec_interface->interface_name); break;
case SWITCH_STATUS_SUCCESS:
session->raw_write_frame.samples = session->raw_write_frame.datalen / sizeof(int16_t);
session->raw_write_frame.timestamp = frame->timestamp;
session->raw_write_frame.rate = frame->rate;
session->raw_write_frame.m = frame->m;
session->raw_write_frame.ssrc = frame->ssrc;
session->raw_write_frame.seq = frame->seq;
session->raw_write_frame.payload = frame->payload;
write_frame = &session->raw_write_frame;
break;
case SWITCH_STATUS_BREAK:
status = SWITCH_STATUS_SUCCESS; goto error;
case SWITCH_STATUS_NOOP:
if (session->write_resampler) {
switch_mutex_lock(session->resample_mutex);
switch_resample_destroy(&session->write_resampler);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
switch_mutex_unlock(session->resample_mutex);
}
write_frame = frame;
status = SWITCH_STATUS_SUCCESS;
break;
default:
if (status == SWITCH_STATUS_NOT_INITALIZED) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
goto error; goto error;
} }
if (ptime_mismatch) {
status = perform_write(session, frame, flags, stream_id);
status = SWITCH_STATUS_SUCCESS; goto error;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s decoder error!\n", frame->codec->codec_interface->interface_name);
goto error;
} }
}
if (session->write_resampler) { if (session->write_resampler) {
short *data = write_frame->data; short *data = write_frame->data;
switch_mutex_lock(session->resample_mutex); switch_mutex_lock(session->resample_mutex);
session->write_resampler->from_len = write_frame->datalen / 2; session->write_resampler->from_len = write_frame->datalen / 2;
switch_short_to_float(data, session->write_resampler->from, session->write_resampler->from_len); switch_short_to_float(data, session->write_resampler->from, session->write_resampler->from_len);
session->write_resampler->to_len = (uint32_t) session->write_resampler->to_len = (uint32_t)
switch_resample_process(session->write_resampler, session->write_resampler->from, switch_resample_process(session->write_resampler, session->write_resampler->from,
session->write_resampler->from_len, session->write_resampler->to, session->write_resampler->to_size, 0); session->write_resampler->from_len, session->write_resampler->to, session->write_resampler->to_size, 0);
switch_float_to_short(session->write_resampler->to, data, session->write_resampler->to_len); switch_float_to_short(session->write_resampler->to, data, session->write_resampler->to_len);
write_frame->samples = session->write_resampler->to_len; write_frame->samples = session->write_resampler->to_len;
write_frame->datalen = write_frame->samples * 2; write_frame->datalen = write_frame->samples * 2;
write_frame->rate = session->write_resampler->to_rate; write_frame->rate = session->write_resampler->to_rate;
switch_mutex_unlock(session->resample_mutex); switch_mutex_unlock(session->resample_mutex);
} }
if (session->bugs) { if (session->bugs) {
switch_media_bug_t *bp, *dp, *last = NULL; switch_media_bug_t *bp, *dp, *last = NULL;
switch_thread_rwlock_rdlock(session->bug_rwlock); switch_thread_rwlock_rdlock(session->bug_rwlock);
for (bp = session->bugs; bp; bp = bp->next) { for (bp = session->bugs; bp; bp = bp->next) {
switch_bool_t ok = SWITCH_TRUE; switch_bool_t ok = SWITCH_TRUE;
if (!bp->ready) { if (!bp->ready) {
continue; continue;
} }
if (switch_test_flag(bp, SMBF_WRITE_STREAM)) { if (switch_test_flag(bp, SMBF_WRITE_STREAM)) {
switch_mutex_lock(bp->write_mutex); switch_mutex_lock(bp->write_mutex);
switch_buffer_write(bp->raw_write_buffer, write_frame->data, write_frame->datalen); switch_buffer_write(bp->raw_write_buffer, write_frame->data, write_frame->datalen);
switch_mutex_unlock(bp->write_mutex); switch_mutex_unlock(bp->write_mutex);
if (bp->callback) { if (bp->callback) {
ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE); ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE);
}
} }
}
if (switch_test_flag(bp, SMBF_WRITE_REPLACE)) { if (switch_test_flag(bp, SMBF_WRITE_REPLACE)) {
do_bugs = 0; do_bugs = 0;
if (bp->callback) { if (bp->callback) {
bp->write_replace_frame_in = write_frame; bp->write_replace_frame_in = write_frame;
bp->write_replace_frame_out = write_frame; bp->write_replace_frame_out = write_frame;
if ((ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE_REPLACE)) == SWITCH_TRUE) { if ((ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE_REPLACE)) == SWITCH_TRUE) {
write_frame = bp->write_replace_frame_out; write_frame = bp->write_replace_frame_out;
}
} }
} }
}
if (bp->stop_time && bp->stop_time <= switch_timestamp(NULL)) { if (bp->stop_time && bp->stop_time <= switch_timestamp(NULL)) {
ok = SWITCH_FALSE; ok = SWITCH_FALSE;
} }
if (ok == SWITCH_FALSE) { if (ok == SWITCH_FALSE) {
bp->ready = 0; bp->ready = 0;
if (last) { if (last) {
last->next = bp->next; last->next = bp->next;
} else { } else {
session->bugs = bp->next; session->bugs = bp->next;
}
dp = bp;
bp = last;
switch_core_media_bug_close(&dp);
if (!bp) {
break;
}
continue;
} }
last = bp; dp = bp;
bp = last;
switch_core_media_bug_close(&dp);
if (!bp) {
break;
}
continue;
} }
switch_thread_rwlock_unlock(session->bug_rwlock); last = bp;
} }
switch_thread_rwlock_unlock(session->bug_rwlock);
}
if (do_bugs) { if (do_bugs) {
do_write = TRUE; do_write = TRUE;
write_frame = frame; write_frame = frame;
goto done; goto done;
} }
if (session->write_codec) { if (session->write_codec) {
if (write_frame->datalen == session->write_codec->implementation->decoded_bytes_per_packet) { if (write_frame->datalen == session->write_codec->implementation->decoded_bytes_per_packet) {
perfect = TRUE; perfect = TRUE;
} else { } else {
if (!session->raw_write_buffer) { if (!session->raw_write_buffer) {
switch_size_t bytes = session->write_codec->implementation->decoded_bytes_per_packet; switch_size_t bytes = session->write_codec->implementation->decoded_bytes_per_packet;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"Engaging Write Buffer at %u bytes to accommodate %u->%u\n", "Engaging Write Buffer at %u bytes to accommodate %u->%u\n",
(uint32_t) bytes, write_frame->datalen, session->write_codec->implementation->decoded_bytes_per_packet); (uint32_t) bytes, write_frame->datalen, session->write_codec->implementation->decoded_bytes_per_packet);
if ((status = switch_buffer_create_dynamic(&session->raw_write_buffer, if ((status = switch_buffer_create_dynamic(&session->raw_write_buffer,
bytes * SWITCH_BUFFER_BLOCK_FRAMES, bytes * SWITCH_BUFFER_BLOCK_FRAMES,
bytes * SWITCH_BUFFER_START_FRAMES, 0)) != SWITCH_STATUS_SUCCESS) { bytes * SWITCH_BUFFER_START_FRAMES, 0)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Write Buffer Failed!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Write Buffer Failed!\n");
goto error; goto error;
}
} }
}
if (!(switch_buffer_write(session->raw_write_buffer, write_frame->data, write_frame->datalen))) { if (!(switch_buffer_write(session->raw_write_buffer, write_frame->data, write_frame->datalen))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Write Buffer %u bytes Failed!\n", write_frame->datalen); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Write Buffer %u bytes Failed!\n", write_frame->datalen);
status = SWITCH_STATUS_MEMERR; goto error; status = SWITCH_STATUS_MEMERR; goto error;
}
} }
}
if (perfect) { if (perfect) {
enc_frame = write_frame; enc_frame = write_frame;
session->enc_write_frame.datalen = session->enc_write_frame.buflen; session->enc_write_frame.datalen = session->enc_write_frame.buflen;
status = switch_core_codec_encode(session->write_codec, status = switch_core_codec_encode(session->write_codec,
frame->codec, frame->codec,
enc_frame->data, enc_frame->data,
enc_frame->datalen, enc_frame->datalen,
session->write_codec->implementation->actual_samples_per_second, session->write_codec->implementation->actual_samples_per_second,
session->enc_write_frame.data, &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag); session->enc_write_frame.data, &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);
switch (status) { switch (status) {
case SWITCH_STATUS_RESAMPLE: case SWITCH_STATUS_RESAMPLE:
/* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Fixme 2\n"); */ /* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Fixme 2\n"); */
case SWITCH_STATUS_SUCCESS: case SWITCH_STATUS_SUCCESS:
session->enc_write_frame.codec = session->write_codec; session->enc_write_frame.codec = session->write_codec;
session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t); session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t);
if (frame->codec->implementation->samples_per_packet != session->write_codec->implementation->samples_per_packet) { if (frame->codec->implementation->samples_per_packet != session->write_codec->implementation->samples_per_packet) {
session->enc_write_frame.timestamp = 0; session->enc_write_frame.timestamp = 0;
} else { } else {
session->enc_write_frame.timestamp = frame->timestamp; session->enc_write_frame.timestamp = frame->timestamp;
}
session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
session->enc_write_frame.seq = frame->seq;
write_frame = &session->enc_write_frame;
break;
case SWITCH_STATUS_NOOP:
enc_frame->codec = session->write_codec;
enc_frame->samples = enc_frame->datalen / sizeof(int16_t);
enc_frame->timestamp = frame->timestamp;
enc_frame->m = frame->m;
enc_frame->seq = frame->seq;
enc_frame->ssrc = frame->ssrc;
enc_frame->payload = enc_frame->codec->implementation->ianacode;
write_frame = enc_frame;
status = SWITCH_STATUS_SUCCESS;
break;
case SWITCH_STATUS_NOT_INITALIZED:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
write_frame = NULL;
goto error;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s encoder error!\n",
session->read_codec->codec_interface->interface_name);
write_frame = NULL;
goto error;
}
if (flag & SFF_CNG) {
switch_set_flag(write_frame, SFF_CNG);
} }
status = perform_write(session, write_frame, flags, stream_id); session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
session->enc_write_frame.seq = frame->seq;
write_frame = &session->enc_write_frame;
break;
case SWITCH_STATUS_NOOP:
enc_frame->codec = session->write_codec;
enc_frame->samples = enc_frame->datalen / sizeof(int16_t);
enc_frame->timestamp = frame->timestamp;
enc_frame->m = frame->m;
enc_frame->seq = frame->seq;
enc_frame->ssrc = frame->ssrc;
enc_frame->payload = enc_frame->codec->implementation->ianacode;
write_frame = enc_frame;
status = SWITCH_STATUS_SUCCESS;
break;
case SWITCH_STATUS_NOT_INITALIZED:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
write_frame = NULL;
goto error;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s encoder error!\n",
session->read_codec->codec_interface->interface_name);
write_frame = NULL;
goto error;
}
if (flag & SFF_CNG) {
switch_set_flag(write_frame, SFF_CNG);
}
status = perform_write(session, write_frame, flags, stream_id);
goto error;
} else {
switch_size_t used = switch_buffer_inuse(session->raw_write_buffer);
uint32_t bytes = session->write_codec->implementation->decoded_bytes_per_packet;
switch_size_t frames = (used / bytes);
status = SWITCH_STATUS_SUCCESS;
if (!frames) {
goto error; goto error;
} else { } else {
switch_size_t used = switch_buffer_inuse(session->raw_write_buffer); switch_size_t x;
uint32_t bytes = session->write_codec->implementation->decoded_bytes_per_packet; for (x = 0; x < frames; x++) {
switch_size_t frames = (used / bytes); if ((session->raw_write_frame.datalen = (uint32_t)
switch_buffer_read(session->raw_write_buffer, session->raw_write_frame.data, bytes)) != 0) {
int rate;
enc_frame = &session->raw_write_frame;
session->raw_write_frame.rate = session->write_codec->implementation->actual_samples_per_second;
session->enc_write_frame.datalen = session->enc_write_frame.buflen;
if (frame->codec && frame->codec->implementation) {
rate = frame->codec->implementation->actual_samples_per_second;
} else {
rate = session->write_codec->implementation->actual_samples_per_second;
}
status = SWITCH_STATUS_SUCCESS; status = switch_core_codec_encode(session->write_codec,
if (!frames) { frame->codec,
goto error; enc_frame->data,
} else { enc_frame->datalen,
switch_size_t x; rate,
for (x = 0; x < frames; x++) { session->enc_write_frame.data,
if ((session->raw_write_frame.datalen = (uint32_t) &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);
switch_buffer_read(session->raw_write_buffer, session->raw_write_frame.data, bytes)) != 0) { switch (status) {
int rate; case SWITCH_STATUS_RESAMPLE:
enc_frame = &session->raw_write_frame; session->enc_write_frame.codec = session->write_codec;
session->raw_write_frame.rate = session->write_codec->implementation->actual_samples_per_second; session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t);
session->enc_write_frame.datalen = session->enc_write_frame.buflen; session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
if (frame->codec && frame->codec->implementation) { session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
rate = frame->codec->implementation->actual_samples_per_second; write_frame = &session->enc_write_frame;
} else { if (!session->write_resampler) {
rate = session->write_codec->implementation->actual_samples_per_second; switch_mutex_lock(session->resample_mutex);
} status = switch_resample_create(&session->write_resampler,
frame->codec->implementation->actual_samples_per_second,
frame->codec->implementation->decoded_bytes_per_packet,
session->write_codec->implementation->actual_samples_per_second,
session->write_codec->implementation->decoded_bytes_per_packet, session->pool);
switch_mutex_unlock(session->resample_mutex);
status = switch_core_codec_encode(session->write_codec, if (status != SWITCH_STATUS_SUCCESS) {
frame->codec, goto done;
enc_frame->data,
enc_frame->datalen,
rate,
session->enc_write_frame.data,
&session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);
switch (status) {
case SWITCH_STATUS_RESAMPLE:
session->enc_write_frame.codec = session->write_codec;
session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t);
session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
write_frame = &session->enc_write_frame;
if (!session->write_resampler) {
switch_mutex_lock(session->resample_mutex);
status = switch_resample_create(&session->write_resampler,
frame->codec->implementation->actual_samples_per_second,
frame->codec->implementation->decoded_bytes_per_packet,
session->write_codec->implementation->actual_samples_per_second,
session->write_codec->implementation->decoded_bytes_per_packet, session->pool);
switch_mutex_unlock(session->resample_mutex);
if (status != SWITCH_STATUS_SUCCESS) {
goto done;
}
} }
break;
case SWITCH_STATUS_SUCCESS:
session->enc_write_frame.codec = session->write_codec;
session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t);
session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
write_frame = &session->enc_write_frame;
break;
case SWITCH_STATUS_NOOP:
if (session->write_resampler) {
switch_mutex_lock(session->resample_mutex);
switch_resample_destroy(&session->write_resampler);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
switch_mutex_unlock(session->resample_mutex);
}
enc_frame->codec = session->write_codec;
enc_frame->samples = enc_frame->datalen / sizeof(int16_t);
enc_frame->m = frame->m;
enc_frame->ssrc = frame->ssrc;
enc_frame->payload = enc_frame->codec->implementation->ianacode;
write_frame = enc_frame;
status = SWITCH_STATUS_SUCCESS;
break;
case SWITCH_STATUS_NOT_INITALIZED:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
write_frame = NULL;
goto error;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s encoder error %d!\n",
session->read_codec->codec_interface->interface_name, status);
write_frame = NULL;
goto error;
} }
break;
if (session->read_resampler) { case SWITCH_STATUS_SUCCESS:
short *data = write_frame->data; session->enc_write_frame.codec = session->write_codec;
session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t);
session->enc_write_frame.m = frame->m;
session->enc_write_frame.ssrc = frame->ssrc;
session->enc_write_frame.payload = session->write_codec->implementation->ianacode;
write_frame = &session->enc_write_frame;
break;
case SWITCH_STATUS_NOOP:
if (session->write_resampler) {
switch_mutex_lock(session->resample_mutex); switch_mutex_lock(session->resample_mutex);
switch_resample_destroy(&session->write_resampler);
session->read_resampler->from_len = switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
switch_short_to_float(data, session->read_resampler->from, (int) write_frame->datalen / 2);
session->read_resampler->to_len = (uint32_t)
switch_resample_process(session->read_resampler, session->read_resampler->from,
session->read_resampler->from_len,
session->read_resampler->to, session->read_resampler->to_size, 0);
switch_float_to_short(session->read_resampler->to, data, write_frame->datalen * 2);
write_frame->samples = session->read_resampler->to_len;
write_frame->datalen = session->read_resampler->to_len * 2;
write_frame->rate = session->read_resampler->to_rate;
switch_mutex_unlock(session->resample_mutex); switch_mutex_unlock(session->resample_mutex);
}
if (flag & SFF_CNG) {
switch_set_flag(write_frame, SFF_CNG);
} }
enc_frame->codec = session->write_codec;
enc_frame->samples = enc_frame->datalen / sizeof(int16_t);
enc_frame->m = frame->m;
enc_frame->ssrc = frame->ssrc;
enc_frame->payload = enc_frame->codec->implementation->ianacode;
write_frame = enc_frame;
status = SWITCH_STATUS_SUCCESS;
break;
case SWITCH_STATUS_NOT_INITALIZED:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec init error!\n");
write_frame = NULL;
goto error;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec %s encoder error %d!\n",
session->read_codec->codec_interface->interface_name, status);
write_frame = NULL;
goto error;
}
if ((status = perform_write(session, write_frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) { if (session->read_resampler) {
break; short *data = write_frame->data;
} switch_mutex_lock(session->resample_mutex);
session->read_resampler->from_len =
switch_short_to_float(data, session->read_resampler->from, (int) write_frame->datalen / 2);
session->read_resampler->to_len = (uint32_t)
switch_resample_process(session->read_resampler, session->read_resampler->from,
session->read_resampler->from_len,
session->read_resampler->to, session->read_resampler->to_size, 0);
switch_float_to_short(session->read_resampler->to, data, write_frame->datalen * 2);
write_frame->samples = session->read_resampler->to_len;
write_frame->datalen = session->read_resampler->to_len * 2;
write_frame->rate = session->read_resampler->to_rate;
switch_mutex_unlock(session->resample_mutex);
}
if (flag & SFF_CNG) {
switch_set_flag(write_frame, SFF_CNG);
}
if ((status = perform_write(session, write_frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
break;
} }
} }
goto error;
} }
goto error;
} }
} }
} else {
do_write = TRUE;
} }
done: done:
if (do_write) { if (do_write) {
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论