added mod_sangoma_codec
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@17110 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Moises Silva
parent
95b891c993
commit
0fd16cc446
|
|
@ -0,0 +1,3 @@
|
|||
BASE=../../../..
|
||||
LOCAL_LDFLAGS += -lsangoma_transcode
|
||||
include $(BASE)/build/modmake.rules
|
||||
|
|
@ -0,0 +1,978 @@
|
|||
/*
|
||||
* Copyright (c) 2010, Sangoma Technologies
|
||||
* Moises Silva <moy@sangoma.com>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* * Neither the name of the original author; nor the names of any contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
|
||||
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <switch.h>
|
||||
#include <g711.h>
|
||||
|
||||
#include <sangoma_transcode.h>
|
||||
|
||||
#ifdef __linux__
|
||||
/* for ethernet device query */
|
||||
#include <sys/ioctl.h>
|
||||
#include <net/if.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
#endif
|
||||
|
||||
SWITCH_MODULE_LOAD_FUNCTION(mod_sangoma_codec_load);
|
||||
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_sangoma_codec_shutdown);
|
||||
SWITCH_MODULE_DEFINITION(mod_sangoma_codec, mod_sangoma_codec_load, mod_sangoma_codec_shutdown, NULL);
|
||||
|
||||
#define IANA_ULAW 0
|
||||
#define SANGOMA_SESS_HASH_KEY_FORMAT "sngtc%lu"
|
||||
|
||||
/* it seemed we need higher PTIME than the calling parties, so we assume nobody will use higher ptime than 40 */
|
||||
#define SANGOMA_DEFAULT_SAMPLING_RATE 80
|
||||
#define SANGOMA_TRANSCODE_CONFIG "sangoma_codec.conf"
|
||||
|
||||
#define SANGOMA_DEFAULT_UDP_PORT 15000
|
||||
#define SANGOMA_MIN_UDP_PORT 0
|
||||
#define SANGOMA_MAX_UDP_PORT 65535
|
||||
|
||||
/* \brief vocallos configuration */
|
||||
static sngtc_init_cfg_t g_init_cfg;
|
||||
|
||||
/* \brief protect vocallo session creation and destroy */
|
||||
static switch_mutex_t *g_sessions_lock = NULL;
|
||||
|
||||
/* \brief next unique session id (protected by g_sessions_lock) */
|
||||
unsigned long long g_next_session_id = 0;
|
||||
|
||||
/* hash of sessions (I think a linked list suits better here, but FS does not have the data type) */
|
||||
switch_hash_t *g_sessions_hash = NULL;
|
||||
|
||||
typedef struct vocallo_codec_s {
|
||||
int codec_id; /* vocallo codec ID */
|
||||
int iana; /* IANA code to register in FS */
|
||||
const char *iana_name; /* IANA name to register in FS */
|
||||
const char *fs_name;
|
||||
int maxms; /* max supported ms */
|
||||
int bps; /* bits per second */
|
||||
|
||||
/* following values must be set assuming frames of 10ms */
|
||||
int mpf; /* microseconds per frame */
|
||||
int spf; /* samples per frame */
|
||||
int bpfd; /* bytes per frame decompressed */
|
||||
int bpfc; /* bytes per frame compressed */
|
||||
} vocallo_codec_t;
|
||||
|
||||
vocallo_codec_t g_codec_map[] =
|
||||
{
|
||||
{ SNGTC_CODEC_PCMU, 0, "PCMU", "Sangoma PCMU", 40, 64000, 10000, 80, 160, 80 },
|
||||
{ SNGTC_CODEC_PCMA, 8, "PCMA", "Sangoma PCMA", 40, 64000, 10000, 80, 160, 80 },
|
||||
{ SNGTC_CODEC_L16_1, 10, "L16", "Sangoma L16", 40, 120000, 10000, 80, 160, 160 },
|
||||
{ SNGTC_CODEC_G729AB, 18, "G729", "Sangoma G729", 40, 8000, 10000, 80, 160, 10 },
|
||||
{ SNGTC_CODEC_G722, 9, "G722", "Sangoma G722", 20, 64000, 10000, 80, 320, 80 },
|
||||
{ SNGTC_CODEC_G726_32, 122, "G726-32", "Sangoma G.726 32k", 40, 32000, 10000, 80, 160, 20 },
|
||||
#if 0
|
||||
FIXME: see mod_ilbc, and mod_voipcodecs to do this right
|
||||
{ SNGTC_CODEC_GSM_FR, 3, "GSM", "Sangoma GSM", 20, 13200, 20000, 160, 320, 33 },
|
||||
{ SNGTC_CODEC_ILBC, 97, "ILBC", "Sangoma ILBC", 40, mpf, spf, bpfd, bpfc },
|
||||
#endif
|
||||
{ -1, -1, NULL, NULL, -1, -1, -1, -1, -1, -1 },
|
||||
};
|
||||
|
||||
struct codec_data {
|
||||
/* sngtc request and reply */
|
||||
sngtc_codec_request_t request;
|
||||
sngtc_codec_reply_t reply;
|
||||
|
||||
/* rtp streams */
|
||||
void *txrtp;
|
||||
void *rxrtp;
|
||||
|
||||
/* packet counters */
|
||||
unsigned long tx;
|
||||
unsigned long rx;
|
||||
|
||||
/* Lost packets */
|
||||
long lastrxseqno;
|
||||
unsigned long rxlost;
|
||||
|
||||
/* avg Rx time */
|
||||
switch_time_t avgrxus;
|
||||
switch_time_t last_rx_time;
|
||||
|
||||
};
|
||||
|
||||
struct sangoma_transcoding_session {
|
||||
/* unique session id */
|
||||
unsigned long sessid;
|
||||
char hashkey[25];
|
||||
|
||||
/* encoder and decoder */
|
||||
struct codec_data encoder;
|
||||
struct codec_data decoder;
|
||||
|
||||
/* codec implementation */
|
||||
const switch_codec_implementation_t *impl;
|
||||
|
||||
/* memory pool */
|
||||
switch_memory_pool_t *pool;
|
||||
};
|
||||
|
||||
static int codec_id_to_iana(int codec_id)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; g_codec_map[i].codec_id != -1; i++) {
|
||||
if (codec_id == g_codec_map[i].codec_id) {
|
||||
return g_codec_map[i].iana;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static vocallo_codec_t *get_codec_from_iana(int iana)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; g_codec_map[i].codec_id != -1; i++) {
|
||||
if (iana == g_codec_map[i].iana) {
|
||||
return &g_codec_map[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int sangoma_create_rtp(void *usr_priv, sngtc_codec_request_leg_t *codec_reg_leg, sngtc_codec_reply_leg_t* codec_reply_leg, void **rtp_fd)
|
||||
{
|
||||
switch_rtp_t *rtp_session = NULL;
|
||||
switch_port_t rtp_port;
|
||||
char codec_ip[255];
|
||||
char local_ip[255];
|
||||
switch_rtp_flag_t flags = 0;
|
||||
int iana = 0;
|
||||
const char *err = NULL;
|
||||
struct sangoma_transcoding_session *sess = usr_priv;
|
||||
struct in_addr local_ip_addr = { 0 };
|
||||
|
||||
local_ip_addr.s_addr = htonl(codec_reply_leg->host_ip);
|
||||
|
||||
switch_inet_ntop(AF_INET, &local_ip_addr, local_ip, sizeof(local_ip));
|
||||
|
||||
/* request a port */
|
||||
if (!(rtp_port = switch_rtp_request_port(local_ip))) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to allocate RTP port for IP %s\n", local_ip);
|
||||
return -1;
|
||||
}
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Allocated port %d for IP %s\n", rtp_port, local_ip);
|
||||
|
||||
codec_reg_leg->host_udp_port = rtp_port;
|
||||
|
||||
sngtc_codec_ipv4_hex_to_str(codec_reply_leg->codec_ip, codec_ip);
|
||||
|
||||
iana = codec_id_to_iana(codec_reg_leg->codec_id);
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Creating RTP session for host (%s/%d) vocallo(%s/%d) Iana=%d sample=%d ms=%d idx=%lu\n",
|
||||
local_ip, rtp_port, codec_ip, codec_reply_leg->codec_udp_port, iana,
|
||||
codec_reg_leg->sample_rate, codec_reg_leg->ms*1000, sess->sessid);
|
||||
|
||||
/* create the RTP socket */
|
||||
rtp_session = switch_rtp_new(local_ip, rtp_port,
|
||||
codec_ip, codec_reply_leg->codec_udp_port,
|
||||
iana,
|
||||
codec_reg_leg->ms*8, /* samples per interval, FIXME: do based on sampling rate */
|
||||
codec_reg_leg->ms*1000, /* ms per packet */
|
||||
flags, NULL, &err, sess->pool);
|
||||
|
||||
if (!rtp_session) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to create switch rtp session: %s\n", err);
|
||||
return -1;
|
||||
}
|
||||
|
||||
*rtp_fd = rtp_session;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sangoma_destroy_rtp(void *usr_priv, void *fd)
|
||||
{
|
||||
switch_rtp_t *rtp = fd;
|
||||
switch_rtp_destroy(&rtp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static switch_status_t switch_sangoma_init(switch_codec_t *codec, switch_codec_flag_t flags, const switch_codec_settings_t *codec_settings)
|
||||
{
|
||||
uint32_t encoding, decoding;
|
||||
struct sangoma_transcoding_session *sess = NULL;
|
||||
vocallo_codec_t *vcodec;
|
||||
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sangoma init called.\n");
|
||||
|
||||
encoding = (flags & SWITCH_CODEC_FLAG_ENCODE);
|
||||
decoding = (flags & SWITCH_CODEC_FLAG_DECODE);
|
||||
|
||||
if (!(encoding || decoding)) {
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (!(sess = switch_core_alloc(codec->memory_pool, sizeof(*sess)))) {
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
memset(sess, 0, sizeof(*sess));
|
||||
|
||||
sess->encoder.lastrxseqno = -1;
|
||||
sess->decoder.lastrxseqno = -1;
|
||||
|
||||
sess->pool = codec->memory_pool;
|
||||
sess->impl = codec->implementation;
|
||||
|
||||
vcodec = get_codec_from_iana(codec->implementation->ianacode);
|
||||
|
||||
switch_mutex_lock(g_sessions_lock);
|
||||
|
||||
if (encoding) {
|
||||
sess->encoder.request.usr_priv = sess;
|
||||
sess->encoder.request.a.codec_id = SNGTC_CODEC_PCMU;
|
||||
sess->encoder.request.a.ms = codec->implementation->microseconds_per_packet/1000;
|
||||
sess->encoder.request.a.sample_rate = codec->implementation->actual_samples_per_second;
|
||||
|
||||
sess->encoder.request.b.codec_id = vcodec->codec_id;
|
||||
sess->encoder.request.b.ms = codec->implementation->microseconds_per_packet/1000;
|
||||
sess->encoder.request.b.sample_rate = codec->implementation->actual_samples_per_second;
|
||||
}
|
||||
|
||||
if (decoding) {
|
||||
sess->decoder.request.usr_priv = sess;
|
||||
sess->decoder.request.a.codec_id = vcodec->codec_id;
|
||||
sess->decoder.request.a.ms = codec->implementation->microseconds_per_packet/1000;
|
||||
sess->decoder.request.a.sample_rate = codec->implementation->actual_samples_per_second;
|
||||
|
||||
sess->decoder.request.b.codec_id = SNGTC_CODEC_PCMU;
|
||||
sess->decoder.request.b.ms = codec->implementation->microseconds_per_packet/1000;
|
||||
sess->decoder.request.b.sample_rate = codec->implementation->actual_samples_per_second;
|
||||
|
||||
}
|
||||
|
||||
sess->sessid = g_next_session_id++;
|
||||
switch_snprintf(sess->hashkey, sizeof(sess->hashkey), SANGOMA_SESS_HASH_KEY_FORMAT, sess->sessid);
|
||||
switch_core_hash_insert(g_sessions_hash, sess->hashkey, sess);
|
||||
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
|
||||
codec->private_info = sess;
|
||||
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static switch_status_t switch_sangoma_encode(switch_codec_t *codec, switch_codec_t *other_codec, /* codec that was used by the other side */
|
||||
void *decoded_data, /* decoded data that we must encode */
|
||||
uint32_t decoded_data_len /* decoded data length */ ,
|
||||
uint32_t decoded_rate /* rate of the decoded data */ ,
|
||||
void *encoded_data, /* here we will store the encoded data */
|
||||
uint32_t *encoded_data_len, /* here we will set the length of the encoded data */
|
||||
uint32_t *encoded_rate /* here we will set the rate of the encoded data */ ,
|
||||
unsigned int *flag /* frame flag, see switch_frame_flag_enum_t */ )
|
||||
{
|
||||
/* FS core checks the actual samples per second and microseconds per packet to determine the buffer size in the worst case scenario, no need to check
|
||||
* whether the buffer passed in by the core (encoded_data) will be big enough */
|
||||
switch_frame_t ulaw_frame;
|
||||
switch_frame_t encoded_frame;
|
||||
switch_status_t sres;
|
||||
switch_time_t now_time, difftime;
|
||||
unsigned char ebuf_ulaw[decoded_data_len / 2];
|
||||
short *dbuf_linear;
|
||||
int i = 0;
|
||||
int res = 0;
|
||||
struct sangoma_transcoding_session *sess = codec->private_info;
|
||||
|
||||
/* start assuming we will not encode anything */
|
||||
*encoded_data_len = 0;
|
||||
|
||||
/* initialize on first use */
|
||||
if (!sess->encoder.txrtp) {
|
||||
int err = 0;
|
||||
switch_mutex_lock(g_sessions_lock);
|
||||
err = sngtc_create_transcoding_session(&sess->encoder.request, &sess->encoder.reply, 0);
|
||||
if (err) {
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to create Sangoma encoding session.\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
sess->encoder.txrtp = sess->encoder.reply.tx_fd;
|
||||
sess->encoder.rxrtp = sess->encoder.reply.rx_fd;
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
}
|
||||
|
||||
/* transcode to ulaw first */
|
||||
dbuf_linear = decoded_data;
|
||||
|
||||
for (i = 0; i < decoded_data_len / sizeof(short); i++) {
|
||||
ebuf_ulaw[i] = linear_to_ulaw(dbuf_linear[i]);
|
||||
}
|
||||
|
||||
/* do the writing */
|
||||
memset(&ulaw_frame, 0, sizeof(ulaw_frame));
|
||||
ulaw_frame.source = __FUNCTION__;
|
||||
ulaw_frame.data = ebuf_ulaw;
|
||||
ulaw_frame.datalen = i;
|
||||
ulaw_frame.payload = IANA_ULAW;
|
||||
|
||||
res = switch_rtp_write_frame(sess->encoder.txrtp, &ulaw_frame);
|
||||
if (-1 == res) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to write to Sangoma encoder RTP session.\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (res < i) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
|
||||
"Requested to write %d bytes to Sangoma encoder RTP session, but wrote %d bytes.\n", i, res);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
sess->encoder.tx++;
|
||||
|
||||
/* do the reading */
|
||||
memset(&encoded_frame, 0, sizeof(encoded_frame));
|
||||
sres = switch_rtp_zerocopy_read_frame(sess->encoder.rxrtp, &encoded_frame, SWITCH_IO_FLAG_NOBLOCK);
|
||||
if (sres == SWITCH_STATUS_GENERR) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to read on Sangoma encoder RTP session: %d\n", sres);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (0 == encoded_frame.datalen) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No output on Sangoma encoder RTP session.\n");
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
if (encoded_frame.payload != codec->implementation->ianacode) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Read unexpected payload %d in Sangoma encoder RTP session, expecting %d\n",
|
||||
encoded_frame.payload, codec->implementation->ianacode);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
memcpy(encoded_data, encoded_frame.data, encoded_frame.datalen);
|
||||
*encoded_data_len = encoded_frame.datalen;
|
||||
|
||||
/* update encoding stats */
|
||||
sess->encoder.rx++;
|
||||
|
||||
now_time = switch_micro_time_now();
|
||||
if (!sess->encoder.last_rx_time) {
|
||||
sess->encoder.last_rx_time = now_time;
|
||||
} else {
|
||||
difftime = now_time - sess->encoder.last_rx_time;
|
||||
sess->encoder.avgrxus = sess->encoder.avgrxus ? ((sess->encoder.avgrxus + difftime)/2) : difftime;
|
||||
sess->encoder.last_rx_time = now_time;
|
||||
}
|
||||
|
||||
/* check sequence and bump lost rx packets count if needed */
|
||||
if (sess->encoder.lastrxseqno >= 0) {
|
||||
if (encoded_frame.seq > (sess->encoder.lastrxseqno + 2) ) {
|
||||
sess->encoder.rxlost += encoded_frame.seq - sess->encoder.lastrxseqno - 1;
|
||||
}
|
||||
}
|
||||
sess->encoder.lastrxseqno = encoded_frame.seq;
|
||||
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static switch_status_t switch_sangoma_decode(switch_codec_t *codec, /* codec session handle */
|
||||
switch_codec_t *other_codec, /* what is this? */
|
||||
void *encoded_data, /* data that we must decode into slinear and put it in decoded_data */
|
||||
uint32_t encoded_data_len, /* length in bytes of the encoded data */
|
||||
uint32_t encoded_rate, /* at which rate was the data encoded */
|
||||
void *decoded_data, /* buffer where we must put the decoded data */
|
||||
uint32_t *decoded_data_len, /* we must set this value to the size of the decoded data */
|
||||
uint32_t *decoded_rate, /* rate of the decoded data */
|
||||
unsigned int *flag /* frame flag, see switch_frame_flag_enum_t */ )
|
||||
{
|
||||
/* FS core checks the actual samples per second and microseconds per packet to determine the buffer size in the worst case scenario, no need to check
|
||||
* whether the buffer passed in by the core will be enough */
|
||||
switch_frame_t encoded_frame;
|
||||
switch_frame_t ulaw_frame;
|
||||
switch_status_t sres;
|
||||
switch_time_t now_time, difftime;
|
||||
short *dbuf_linear;
|
||||
int i = 0;
|
||||
int res = 0;
|
||||
struct sangoma_transcoding_session *sess = codec->private_info;
|
||||
|
||||
dbuf_linear = decoded_data;
|
||||
|
||||
/* start assuming we will not decode anything */
|
||||
*decoded_data_len = 0;
|
||||
if (*flag & SWITCH_CODEC_FLAG_SILENCE) {
|
||||
memset(dbuf_linear, 0, codec->implementation->decoded_bytes_per_packet);
|
||||
*decoded_data_len = codec->implementation->decoded_bytes_per_packet;
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Returned silence on request\n");
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
/* initialize on first use */
|
||||
if (!sess->decoder.txrtp) {
|
||||
int err = 0;
|
||||
switch_mutex_lock(g_sessions_lock);
|
||||
err = sngtc_create_transcoding_session(&sess->decoder.request, &sess->decoder.reply, 0);
|
||||
if (err) {
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to create Sangoma decoding session.\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
sess->decoder.txrtp = sess->decoder.reply.tx_fd;
|
||||
sess->decoder.rxrtp = sess->decoder.reply.rx_fd;
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
}
|
||||
|
||||
/* do the writing */
|
||||
memset(&encoded_frame, 0, sizeof(encoded_frame));
|
||||
encoded_frame.source = __FUNCTION__;
|
||||
encoded_frame.data = encoded_data;
|
||||
encoded_frame.datalen = encoded_data_len;
|
||||
encoded_frame.payload = codec->implementation->ianacode;
|
||||
|
||||
res = switch_rtp_write_frame(sess->decoder.txrtp, &encoded_frame);
|
||||
if (-1 == res) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to write to Sangoma decoder RTP session.\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (res < encoded_data_len) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
|
||||
"Requested to write %d bytes to Sangoma decoder RTP session, but wrote %d bytes.\n",
|
||||
encoded_data_len, res);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
sess->decoder.tx++;
|
||||
|
||||
/* do the reading */
|
||||
memset(&ulaw_frame, 0, sizeof(ulaw_frame));
|
||||
sres = switch_rtp_zerocopy_read_frame(sess->decoder.rxrtp, &ulaw_frame, SWITCH_IO_FLAG_NOBLOCK);
|
||||
if (sres == SWITCH_STATUS_GENERR) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to read on Sangoma decoder RTP session: %d\n", sres);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (0 == ulaw_frame.datalen) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No output on Sangoma decoder RTP session.\n");
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
if (ulaw_frame.payload != IANA_ULAW) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Read unexpected payload %d in Sangoma decoder RTP session, expecting %d\n",
|
||||
ulaw_frame.payload, IANA_ULAW);
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
/* transcode to linear */
|
||||
for (i = 0; i < ulaw_frame.datalen; i++) {
|
||||
dbuf_linear[i] = ulaw_to_linear(((char *)ulaw_frame.data)[i]);
|
||||
}
|
||||
*decoded_data_len = i * 2;
|
||||
|
||||
/* update decoding stats */
|
||||
sess->decoder.rx++;
|
||||
|
||||
now_time = switch_micro_time_now();
|
||||
if (!sess->decoder.last_rx_time) {
|
||||
sess->decoder.last_rx_time = now_time;
|
||||
} else {
|
||||
difftime = now_time - sess->decoder.last_rx_time;
|
||||
sess->decoder.avgrxus = sess->decoder.avgrxus ? ((sess->decoder.avgrxus + difftime)/2) : difftime;
|
||||
sess->decoder.last_rx_time = now_time;
|
||||
}
|
||||
|
||||
/* check sequence and bump lost rx packets count if needed */
|
||||
if (sess->decoder.lastrxseqno >= 0) {
|
||||
if (ulaw_frame.seq > (sess->decoder.lastrxseqno + 2) ) {
|
||||
sess->decoder.rxlost += ulaw_frame.seq - sess->decoder.lastrxseqno - 1;
|
||||
}
|
||||
}
|
||||
sess->decoder.lastrxseqno = ulaw_frame.seq;
|
||||
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static switch_status_t switch_sangoma_destroy(switch_codec_t *codec)
|
||||
{
|
||||
struct sangoma_transcoding_session *sess = codec->private_info;
|
||||
/* things that you may do here is closing files, sockets or other resources used during the codec session
|
||||
* no need to free memory allocated from the pool though, the owner of the pool takes care of that */
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sangoma destroy called.\n");
|
||||
|
||||
switch_mutex_lock(g_sessions_lock);
|
||||
|
||||
if (sess->encoder.reply.codec_rtp_session) {
|
||||
sngtc_destroy_transcoding_session(sess->encoder.reply.codec_rtp_session);
|
||||
}
|
||||
if (sess->decoder.reply.codec_rtp_session) {
|
||||
sngtc_destroy_transcoding_session(sess->decoder.reply.codec_rtp_session);
|
||||
}
|
||||
|
||||
switch_core_hash_delete(g_sessions_hash, sess->hashkey);
|
||||
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static struct sangoma_transcoding_session *sangoma_find_session(unsigned long sessid)
|
||||
{
|
||||
char hashkey[50];
|
||||
snprintf(hashkey, sizeof(hashkey), SANGOMA_SESS_HASH_KEY_FORMAT, sessid);
|
||||
return switch_core_hash_find(g_sessions_hash, hashkey);
|
||||
}
|
||||
|
||||
static void sangoma_print_stats(switch_stream_handle_t *stream, switch_rtp_numbers_t *stats)
|
||||
{
|
||||
stream->write_function(stream, "Raw bytes: %lu\n", stats->raw_bytes);
|
||||
stream->write_function(stream, "Media bytes: %lu\n", stats->media_bytes);
|
||||
stream->write_function(stream, "Packet count: %lu\n", stats->packet_count);
|
||||
stream->write_function(stream, "Media packet count: %lu\n", stats->media_packet_count);
|
||||
stream->write_function(stream, "Skip packet count: %lu\n", stats->skip_packet_count);
|
||||
stream->write_function(stream, "Jitter buffer packet count: %lu\n", stats->jb_packet_count);
|
||||
stream->write_function(stream, "DTMF packet count: %lu\n", stats->dtmf_packet_count);
|
||||
stream->write_function(stream, "CNG packet count: %lu\n", stats->cng_packet_count);
|
||||
stream->write_function(stream, "Flush packet count: %lu\n\n\n", stats->flush_packet_count);
|
||||
}
|
||||
|
||||
#define SANGOMA_SYNTAX "settings|sessions|stats <session>"
|
||||
SWITCH_STANDARD_API(sangoma_function)
|
||||
{
|
||||
char *argv[10] = { 0 };
|
||||
int argc = 0;
|
||||
char *mycmd = NULL;
|
||||
|
||||
if (zstr(cmd)) {
|
||||
stream->write_function(stream, "%s", SANGOMA_SYNTAX);
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
if (!(mycmd = strdup(cmd))) {
|
||||
return SWITCH_STATUS_MEMERR;
|
||||
}
|
||||
|
||||
if (!(argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) || !argv[0]) {
|
||||
stream->write_function(stream, "%s", SANGOMA_SYNTAX);
|
||||
switch_safe_free(mycmd);
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
#if 0
|
||||
FIXME: settings per vocallo
|
||||
if (!strcasecmp(argv[0], "settings")) {
|
||||
char ip_buff[50];
|
||||
stream->write_function(stream, "UDP port range: %d\n", g_sangoma_baseudp);
|
||||
|
||||
stream->write_function(stream, "localaddr: %s\n",
|
||||
switch_inet_ntop(AF_INET, &g_sangoma_local_ip, ip_buff, sizeof(ip_buff)));
|
||||
|
||||
stream->write_function(stream, "vocallohost: %s\n",
|
||||
switch_inet_ntop(AF_INET, &g_sangoma_vocallo_ip, ip_buff, sizeof(ip_buff)));
|
||||
|
||||
stream->write_function(stream, "netmask: %s\n",
|
||||
switch_inet_ntop(AF_INET, &g_sangoma_local_netmask, ip_buff, sizeof(ip_buff)));
|
||||
|
||||
} else if (!strcasecmp(argv[0], "sessions")) {
|
||||
#endif
|
||||
if (!strcasecmp(argv[0], "sessions")) {
|
||||
/* iterate over sessions hash */
|
||||
switch_hash_index_t *hi;
|
||||
const void *var;
|
||||
void *val;
|
||||
unsigned totalsess = 0;
|
||||
switch_mutex_lock(g_sessions_lock);
|
||||
#define STATS_FORMAT "%-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-10.10s %-15.15s %-15.15s\n"
|
||||
stream->write_function(stream, STATS_FORMAT,
|
||||
"Session", "Codec", "Enc", "Dec", "Enc Tx", "Enc Rx", "Dec Tx", "Dec Rx", "Enc Lost", "Dec Lost", "Enc AvgRxMs", "Dec AvgRxMs");
|
||||
for (hi = switch_hash_first(NULL, g_sessions_hash); hi; hi = switch_hash_next(hi)) {
|
||||
struct sangoma_transcoding_session *sess;
|
||||
char sessid_str[25];
|
||||
char encoder_tx_str[25];
|
||||
char encoder_rx_str[25];
|
||||
char decoder_tx_str[25];
|
||||
char decoder_rx_str[25];
|
||||
char encoder_lostrx_str[25];
|
||||
char decoder_lostrx_str[25];
|
||||
char encoder_avgrxus_str[25];
|
||||
char decoder_avgrxus_str[25];
|
||||
|
||||
switch_hash_this(hi, &var, NULL, &val);
|
||||
sess = val;
|
||||
|
||||
snprintf(sessid_str, sizeof(sessid_str), "%lu", sess->sessid);
|
||||
snprintf(encoder_tx_str, sizeof(encoder_tx_str), "%lu", sess->encoder.tx);
|
||||
snprintf(encoder_rx_str, sizeof(encoder_rx_str), "%lu", sess->encoder.rx);
|
||||
snprintf(decoder_tx_str, sizeof(decoder_tx_str), "%lu", sess->decoder.tx);
|
||||
snprintf(decoder_rx_str, sizeof(decoder_rx_str), "%lu", sess->decoder.rx);
|
||||
snprintf(encoder_lostrx_str, sizeof(encoder_lostrx_str), "%lu", sess->encoder.rxlost);
|
||||
snprintf(decoder_lostrx_str, sizeof(decoder_lostrx_str), "%lu", sess->decoder.rxlost);
|
||||
snprintf(encoder_avgrxus_str, sizeof(encoder_avgrxus_str), "%ld", (long)(sess->encoder.avgrxus/1000));
|
||||
snprintf(decoder_avgrxus_str, sizeof(encoder_avgrxus_str), "%ld", (long)(sess->decoder.avgrxus/1000));
|
||||
|
||||
|
||||
stream->write_function(stream, STATS_FORMAT,
|
||||
sessid_str,
|
||||
sess->impl->iananame,
|
||||
sess->encoder.txrtp ? "Yes" : "No",
|
||||
sess->decoder.txrtp ? "Yes" : "No",
|
||||
encoder_tx_str,
|
||||
encoder_rx_str,
|
||||
decoder_tx_str,
|
||||
decoder_rx_str,
|
||||
encoder_lostrx_str,
|
||||
decoder_lostrx_str,
|
||||
encoder_avgrxus_str,
|
||||
decoder_avgrxus_str);
|
||||
totalsess++;
|
||||
}
|
||||
switch_mutex_unlock(g_sessions_lock);
|
||||
stream->write_function(stream, "Total sessions: %d\n", totalsess);
|
||||
} else if (!strcasecmp(argv[0], "stats")) {
|
||||
struct sangoma_transcoding_session *sess;
|
||||
unsigned long sessid = 0;
|
||||
switch_rtp_stats_t *stats = NULL;
|
||||
int ret = 0;
|
||||
if (argc < 2) {
|
||||
stream->write_function(stream, "%s", SANGOMA_SYNTAX);
|
||||
goto done;
|
||||
}
|
||||
ret = sscanf(argv[1], "%lu", &sessid);
|
||||
if (ret != 1) {
|
||||
stream->write_function(stream, "%s", SANGOMA_SYNTAX);
|
||||
goto done;
|
||||
}
|
||||
sess = sangoma_find_session(sessid);
|
||||
if (!sess) {
|
||||
stream->write_function(stream, "Failed to find session %lu\n", sessid);
|
||||
goto done;
|
||||
}
|
||||
stream->write_function(stream, "Session: %lu\n", sessid);
|
||||
|
||||
if (sess->encoder.rxrtp) {
|
||||
stats = switch_rtp_get_stats(sess->encoder.rxrtp, NULL);
|
||||
stream->write_function(stream, "-- Encoder Inbound Stats --\n");
|
||||
sangoma_print_stats(stream, &stats->inbound);
|
||||
|
||||
|
||||
stats = switch_rtp_get_stats(sess->encoder.txrtp, NULL);
|
||||
stream->write_function(stream, "-- Encoder Outbound Stats --\n");
|
||||
sangoma_print_stats(stream, &stats->outbound);
|
||||
}
|
||||
|
||||
if (sess->decoder.rxrtp) {
|
||||
stats = switch_rtp_get_stats(sess->decoder.rxrtp, NULL);
|
||||
stream->write_function(stream, "-- Decoder Inbound Stats --\n");
|
||||
sangoma_print_stats(stream, &stats->inbound);
|
||||
|
||||
stats = switch_rtp_get_stats(sess->decoder.txrtp, NULL);
|
||||
stream->write_function(stream, "-- Decoder Outbound Stats --\n");
|
||||
sangoma_print_stats(stream, &stats->outbound);
|
||||
}
|
||||
} else {
|
||||
stream->write_function(stream, "Unknown Command [%s]\n", argv[0]);
|
||||
}
|
||||
|
||||
done:
|
||||
switch_safe_free(mycmd);
|
||||
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static int sangoma_logger(int level, char *fmt, ...)
|
||||
{
|
||||
char *data;
|
||||
int ret = 0;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
ret = switch_vasprintf(&data, fmt, ap);
|
||||
if (ret == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
switch (level) {
|
||||
case SNGTC_LOGLEVEL_DEBUG:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s\n", data);
|
||||
break;
|
||||
case SNGTC_LOGLEVEL_WARN:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s\n", data);
|
||||
break;
|
||||
case SNGTC_LOGLEVEL_INFO:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s\n", data);
|
||||
break;
|
||||
case SNGTC_LOGLEVEL_STATS:
|
||||
break;
|
||||
case SNGTC_LOGLEVEL_ERROR:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s\n", data);
|
||||
break;
|
||||
case SNGTC_LOGLEVEL_CRIT:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s\n", data);
|
||||
break;
|
||||
default:
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unexpected msg with loglevel %d: %s\n", level, data);
|
||||
}
|
||||
|
||||
free(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int load_nic_network_information(const char *nic, sngtc_host_nic_vocallo_cfg_t *cfg)
|
||||
{
|
||||
#ifdef __linux__
|
||||
struct ifreq ifr;
|
||||
int sock;
|
||||
char *mac;
|
||||
int j = 0, k = 0, ret = 0;
|
||||
|
||||
sock = socket(PF_INET, SOCK_STREAM, 0);
|
||||
if (-1 == sock) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
|
||||
"Failed to create socket to query network configuration for NIC %s: %s\n", nic, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
strncpy(ifr.ifr_name, nic, sizeof(ifr.ifr_name)-1);
|
||||
ifr.ifr_name[sizeof(ifr.ifr_name)-1] = '\0';
|
||||
|
||||
if (-1 == ioctl(sock, SIOCGIFADDR, &ifr)) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to query IP address for NIC %s: %s\n", nic, strerror(errno));
|
||||
ret = -1;
|
||||
goto done;
|
||||
}
|
||||
cfg->host_ip = ntohl(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr);
|
||||
|
||||
if (-1 == ioctl(sock, SIOCGIFNETMASK, &ifr)) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to query network address for NIC %s: %s\n", nic, strerror(errno));
|
||||
ret = -1;
|
||||
goto done;
|
||||
}
|
||||
cfg->host_ip_netmask = ntohl(((struct sockaddr_in *)&ifr.ifr_netmask)->sin_addr.s_addr);
|
||||
|
||||
if (-1 == ioctl(sock, SIOCGIFHWADDR, &ifr)) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to query HW address for NIC %s: %s\n", nic, strerror(errno));
|
||||
ret = -1;
|
||||
goto done;
|
||||
}
|
||||
|
||||
mac = cfg->host_mac.mac_str;
|
||||
for (j = 0, k = 0; j < 6; j++) {
|
||||
k += snprintf(mac + k, sizeof(cfg->host_mac.mac_str) - k, j ? "-%02X" : "%02X",
|
||||
(int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
|
||||
}
|
||||
mac[sizeof(cfg->host_mac.mac_str)-1] = '\0';
|
||||
|
||||
done:
|
||||
close(sock);
|
||||
return ret;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
static int sangoma_parse_config(void)
|
||||
{
|
||||
switch_xml_t cfg, settings, param, vocallos, xml, vocallo;
|
||||
struct in_addr vocallo_base_ip;
|
||||
char ipbuff[50];
|
||||
char netbuff[50];
|
||||
int vidx = 0;
|
||||
int baseudp = 0;
|
||||
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Reading sangoma codec configuration\n");
|
||||
if (!(xml = switch_xml_open_cfg(SANGOMA_TRANSCODE_CONFIG, &cfg, NULL))) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to open sangoma codec configuration %s\n", SANGOMA_TRANSCODE_CONFIG);
|
||||
return -1;
|
||||
}
|
||||
|
||||
memset(&g_init_cfg, 0, sizeof(g_init_cfg));
|
||||
|
||||
if ((settings = switch_xml_child(cfg, "settings"))) {
|
||||
/* nothing here yet */
|
||||
}
|
||||
|
||||
if ((vocallos = switch_xml_child(cfg, "vocallos"))) {
|
||||
for (vocallo = switch_xml_child(vocallos, "vocallo"); vocallo; vocallo = vocallo->next) {
|
||||
const char *name = switch_xml_attr(vocallo, "name");
|
||||
if (!name) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Sangoma vocallo found with no name= attribute, ignoring!\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
if (load_nic_network_information(name, &g_init_cfg.host_nic_vocallo_cfg[vidx])) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
|
||||
"Ignoring vocallo %s, failed to retrieve its network configuration\n", name);
|
||||
continue;
|
||||
}
|
||||
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Configuring vocallo %s\n", name);
|
||||
|
||||
g_init_cfg.host_nic_vocallo_cfg[vidx].vocallo_base_udp_port = SANGOMA_DEFAULT_UDP_PORT;
|
||||
for (param = switch_xml_child(vocallo, "param"); param; param = param->next) {
|
||||
char *var = (char *)switch_xml_attr_soft(param, "name");
|
||||
char *val = (char *)switch_xml_attr_soft(param, "value");
|
||||
|
||||
/* starting UDP port to be used by the vocallo modules */
|
||||
if (!strcasecmp(var, "baseudp")) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Found Sangoma codec base udp port %s\n", val);
|
||||
baseudp = atoi(val);
|
||||
if (baseudp < SANGOMA_MIN_UDP_PORT || baseudp > SANGOMA_MAX_UDP_PORT) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
|
||||
"Invalid Sangoma codec base udp port %s, using default %d\n",
|
||||
val, SANGOMA_DEFAULT_UDP_PORT);
|
||||
break;
|
||||
}
|
||||
g_init_cfg.host_nic_vocallo_cfg[vidx].vocallo_base_udp_port = baseudp;
|
||||
}
|
||||
else if (!strcasecmp(var, "vocalloaddr")) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Found Sangoma codec vocallo addr %s\n", val);
|
||||
if (switch_inet_pton(AF_INET, val, &vocallo_base_ip) <= 0) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid Sangoma codec vocallo addr %s\n", val);
|
||||
break;
|
||||
}
|
||||
g_init_cfg.host_nic_vocallo_cfg[vidx].vocallo_ip = ntohl(vocallo_base_ip.s_addr);
|
||||
} else {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Ignored unknown Sangoma codec setting %s\n", val);
|
||||
}
|
||||
}
|
||||
|
||||
if (!g_init_cfg.host_nic_vocallo_cfg[vidx].vocallo_ip) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Ignoring vocallo %s, no valid address was configured\n", name);
|
||||
continue;
|
||||
}
|
||||
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
|
||||
"Sangoma transcoding interface %s using IP address %s, netmask %s\n",
|
||||
name,
|
||||
switch_inet_ntop(AF_INET, &g_init_cfg.host_nic_vocallo_cfg[vidx].host_ip, ipbuff, sizeof(ipbuff)),
|
||||
switch_inet_ntop(AF_INET, &g_init_cfg.host_nic_vocallo_cfg[vidx].host_ip_netmask, netbuff, sizeof(netbuff)));
|
||||
vidx++;
|
||||
}
|
||||
} else {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No <vocallos> section found in configuration file %s\n", SANGOMA_TRANSCODE_CONFIG);
|
||||
}
|
||||
|
||||
switch_xml_free(xml);
|
||||
|
||||
if (!vidx) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
|
||||
"No vocallos were configured, make sure there is at least one <vocallo> in %s.\n", SANGOMA_TRANSCODE_CONFIG);
|
||||
}
|
||||
|
||||
g_init_cfg.host_nic_vocallo_sz = vidx;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_sangoma_codec_shutdown)
|
||||
{
|
||||
switch_core_hash_destroy(&g_sessions_hash);
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
SWITCH_MODULE_LOAD_FUNCTION(mod_sangoma_codec_load)
|
||||
{
|
||||
/* the codec interface that will be registered with the core */
|
||||
switch_codec_interface_t *codec_interface = NULL;
|
||||
switch_api_interface_t *api_interface = NULL;
|
||||
int i = 0, c = 0;
|
||||
int detected = 0, activated = 0;
|
||||
|
||||
/* make sure we have valid configuration */
|
||||
if (sangoma_parse_config()) {
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
g_init_cfg.log = sangoma_logger;
|
||||
g_init_cfg.create_rtp = sangoma_create_rtp;
|
||||
g_init_cfg.destroy_rtp = sangoma_destroy_rtp;
|
||||
|
||||
if (sngtc_detect_init_modules(&g_init_cfg, &detected)) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to detect vocallo modules\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
|
||||
if (sngtc_activate_modules(&g_init_cfg, &activated)) {
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to activate vocallo modules\n");
|
||||
return SWITCH_STATUS_FALSE;
|
||||
}
|
||||
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Detected %d and activated %d Sangoma codec vocallo modules\n", detected, activated);
|
||||
|
||||
switch_mutex_init(&g_sessions_lock, SWITCH_MUTEX_UNNESTED, pool);
|
||||
|
||||
switch_core_hash_init(&g_sessions_hash, pool);
|
||||
|
||||
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
|
||||
|
||||
for (c = 0; g_codec_map[c].codec_id != -1; c++) {
|
||||
/* SWITCH_ADD_CODEC allocates a codec interface structure from the pool the core gave us and adds it to the internal interface
|
||||
* list the core keeps, gets a codec id and set the given codec name to it.
|
||||
* At this point there is an empty shell codec interface registered, but not yet implementations */
|
||||
SWITCH_ADD_CODEC(codec_interface, g_codec_map[c].fs_name);
|
||||
|
||||
/* Now add as many codec implementations as needed, just up to 40ms for now */
|
||||
for (i = 1; i <= 4; i++) {
|
||||
|
||||
if ((g_codec_map[c].maxms/10) < i) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch_core_codec_add_implementation(pool, codec_interface, /* the codec interface we allocated and we want to register with the core */
|
||||
SWITCH_CODEC_TYPE_AUDIO, /* enumeration defining the type of the codec */
|
||||
g_codec_map[c].iana, /* the IANA code number, ie http://www.iana.org/assignments/rtp-parameters */
|
||||
g_codec_map[c].iana_name, /* the IANA code name */
|
||||
NULL, /* default fmtp to send (can be overridden by the init function), fmtp is used in SDP for format specific parameters */
|
||||
8000, /* samples transferred per second */
|
||||
8000, /* actual samples transferred per second */
|
||||
g_codec_map[c].bps, /* bits transferred per second */
|
||||
g_codec_map[c].mpf * i, /* microseconds per frame */
|
||||
g_codec_map[c].spf * i, /* samples per frame */
|
||||
g_codec_map[c].bpfd * i, /* number of bytes per frame decompressed */
|
||||
g_codec_map[c].bpfc * i, /* number of bytes per frame compressed */
|
||||
1, /* number of channels represented */
|
||||
g_codec_map[c].spf * i, /* number of frames per network packet (I dont think this is used at all) */
|
||||
switch_sangoma_init, /* function to initialize a codec session using this implementation */
|
||||
switch_sangoma_encode, /* function to encode slinear data into encoded data */
|
||||
switch_sangoma_decode, /* function to decode encoded data into slinear data */
|
||||
switch_sangoma_destroy); /* deinitalize a codec handle using this implementation */
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SWITCH_ADD_API(api_interface, "sangoma_codec", "Sangoma Codec Commands", sangoma_function, SANGOMA_SYNTAX);
|
||||
switch_console_set_complete("add sangoma_codec");
|
||||
switch_console_set_complete("add sangoma_codec settings");
|
||||
switch_console_set_complete("add sangoma_codec sessions");
|
||||
switch_console_set_complete("add sangoma_codec stats");
|
||||
|
||||
return SWITCH_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
/* For Emacs:
|
||||
* Local Variables:
|
||||
* mode:c
|
||||
* indent-tabs-mode:t
|
||||
* tab-width:4
|
||||
* c-basic-offset:4
|
||||
* End:
|
||||
* For VIM:
|
||||
* vim:set softtabstop=4 shiftwidth=4 tabstop=4:
|
||||
*/
|
||||
Loading…
Reference in New Issue