int ast_format_rate(const struct ast_format *format)
{
switch (format->id) {
case AST_FORMAT_SLINEAR12:
return 12000;
case AST_FORMAT_SLINEAR24:
return 24000;
case AST_FORMAT_SLINEAR32:
return 32000;
case AST_FORMAT_SLINEAR44:
return 44100;
case AST_FORMAT_SLINEAR48:
return 48000;
case AST_FORMAT_SLINEAR96:
return 96000;
case AST_FORMAT_SLINEAR192:
return 192000;
case AST_FORMAT_G722:
case AST_FORMAT_SLINEAR16:
case AST_FORMAT_SIREN7:
case AST_FORMAT_SPEEX16:
return 16000;
case AST_FORMAT_SIREN14:
case AST_FORMAT_SPEEX32:
return 32000;
case AST_FORMAT_G719:
return 48000;
case AST_FORMAT_SILK:
if (!(ast_format_isset(format,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_24KHZ,
AST_FORMAT_ATTR_END))) {
return 24000;
} else if (!(ast_format_isset(format,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_16KHZ,
AST_FORMAT_ATTR_END))) {
return 16000;
} else if (!(ast_format_isset(format,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_12KHZ,
AST_FORMAT_ATTR_END))) {
return 12000;
} else {
return 8000;
}
case AST_FORMAT_CELT:
{
int samplerate;
if (!(ast_format_get_value(format,
CELT_ATTR_KEY_SAMP_RATE,
&samplerate))) {
return samplerate;
}
}
default:
return 8000;
}
}
static int lintosilk_new(struct ast_trans_pvt *pvt)
{
SKP_int32 ret;
int silk_samplerate = 8000;
int slin_samplerate = 8000;
struct silk_coder_pvt *coder = pvt->pvt;
char format_string[100];
char* pointer = format_string;
char* format;
struct ast_format format_struct;
struct ast_format* format_def = &format_struct;
int attr_dtx = 0,
attr_fec = 0,
attr_pktloss_pct = 0,
attr_max_bitrate = 0,
attr_samp_rate = 0;
/* init the silk encoder */
coder->psEnc = malloc(encSizeBytes);
ret = SKP_Silk_SDK_InitEncoder(coder->psEnc, &coder->encControl);
if (ret) {
ast_log(LOG_WARNING, "SKP_Silk_SDK_InitEncoder returned %d\n", ret);
}
/* Get the names of the silk codecs */
ast_getformatname_multiple_byid(format_string, sizeof(format_string), AST_FORMAT_SILK);
/* The destination sample rate is set explicitly */
ret = ast_format_get_value(&pvt->explicit_dst, SILK_ATTR_KEY_SAMP_RATE, &attr_samp_rate);
switch(attr_samp_rate){
case SILK_ATTR_VAL_SAMP_8KHZ: silk_samplerate = 8000; break;
case SILK_ATTR_VAL_SAMP_12KHZ: silk_samplerate = 12000; break;
case SILK_ATTR_VAL_SAMP_16KHZ: silk_samplerate = 16000; break;
case SILK_ATTR_VAL_SAMP_24KHZ: silk_samplerate = 24000; break;
}
/* get the source rate */
switch(pvt->t->src_format.id){
case AST_FORMAT_SLINEAR: slin_samplerate = 8000; break;
case AST_FORMAT_SLINEAR12: slin_samplerate = 12000; break;
case AST_FORMAT_SLINEAR16: slin_samplerate = 16000; break;
case AST_FORMAT_SLINEAR24: slin_samplerate = 24000; break;
default: slin_samplerate = 8000; break;
}
/* SILK Docs say that internal sampling rate > API Sampling rate is not allowed */
if(slin_samplerate < silk_samplerate){
silk_samplerate = slin_samplerate;
}
/* set the parameters for the coder */
coder->encControl.API_sampleRate = (SKP_int32)slin_samplerate; /* lin input rate */
coder->encControl.maxInternalSampleRate = (SKP_int32)silk_samplerate; /* silk output rate */
coder->encControl.packetSize = (packetSize_ms * slin_samplerate) / 1000;
coder->encControl.complexity = complexity;
while ((format = strsep(&pointer, "(|)"))){
if(strlen(format) > 0){
if((format_def = ast_getformatbyname(format, format_def))){
/* now pull out the format attributes */
ret = ast_format_get_value(format_def, SILK_ATTR_KEY_DTX, &attr_dtx);
coder->encControl.useDTX = !ret ? (SKP_int32)attr_dtx : useDTX;
ret = ast_format_get_value(format_def, SILK_ATTR_KEY_FEC, &attr_fec);
coder->encControl.useInBandFEC = !ret ? (SKP_int32)attr_fec : useInBandFEC;
ret = ast_format_get_value(format_def, SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE, &attr_pktloss_pct);
coder->encControl.packetLossPercentage = !ret ? (SKP_int32)attr_pktloss_pct : packetLossPercentage;
ret = ast_format_get_value(format_def, SILK_ATTR_KEY_MAX_BITRATE, &attr_max_bitrate);
coder->encControl.bitRate = !ret ? (SKP_int32)attr_max_bitrate : bitRate;
break;
}
}
}
return 0;
}
static int load_module(void)
{
SKP_int32 ret = 0;;
int res = 0;
char format_string[100];
char* format;
char* pointer = format_string;
struct ast_format format_struct;
struct ast_format* format_def = &format_struct;
int attr_samp_rate = 0;
/* print the skype version */
ast_log(LOG_NOTICE, "SILK Version : %s\n", SKP_Silk_SDK_get_version());
/* get the encoder / decoder sizes */
ret = SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes);
if (ret) {
ast_log(LOG_WARNING, "SKP_Silk_SDK_Get_Encoder_size returned %d", ret);
}
ret = SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes);
if (ret) {
ast_log(LOG_WARNING, "SKP_Silk_SDK_Get_Decoder_size returned %d", ret);
}
/* Finish the setup of the encoders / decoders */
/* silk8 */
ast_format_set(&silk8tolin.src_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_8KHZ,
AST_FORMAT_ATTR_END);
ast_format_set(&silk8tolin.dst_format, AST_FORMAT_SLINEAR,0);
ast_format_set(&lintosilk8.src_format, AST_FORMAT_SLINEAR,0);
ast_format_set(&lintosilk8.dst_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_8KHZ,
AST_FORMAT_ATTR_END);
/* silk12 */
ast_format_set(&silk12tolin.src_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_12KHZ,
AST_FORMAT_ATTR_END);
ast_format_set(&silk12tolin.dst_format, AST_FORMAT_SLINEAR12,0);
ast_format_set(&lintosilk12.src_format, AST_FORMAT_SLINEAR12,0);
ast_format_set(&lintosilk12.dst_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_12KHZ,
AST_FORMAT_ATTR_END);
/* silk16 */
ast_format_set(&silk16tolin.src_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_16KHZ,
AST_FORMAT_ATTR_END);
ast_format_set(&silk16tolin.dst_format, AST_FORMAT_SLINEAR16,0);
ast_format_set(&lintosilk16.src_format, AST_FORMAT_SLINEAR16,0);
ast_format_set(&lintosilk16.dst_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_16KHZ,
AST_FORMAT_ATTR_END);
/* silk24 */
ast_format_set(&silk24tolin.src_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_24KHZ,
AST_FORMAT_ATTR_END);
ast_format_set(&silk24tolin.dst_format, AST_FORMAT_SLINEAR24,0);
ast_format_set(&lintosilk24.src_format, AST_FORMAT_SLINEAR24,0);
ast_format_set(&lintosilk24.dst_format, AST_FORMAT_SILK,1,
SILK_ATTR_KEY_SAMP_RATE,
SILK_ATTR_VAL_SAMP_24KHZ,
AST_FORMAT_ATTR_END);
/* Get the names of the silk codecs */
ast_getformatname_multiple_byid(format_string, sizeof(format_string), AST_FORMAT_SILK);
ast_log(LOG_NOTICE, "Defined silk codecs are: %s\n", format_string);
while ((format = strsep(&pointer, "(|)"))){
if(strlen(format) > 0){
if((format_def = ast_getformatbyname(format, format_def))){
/* now pull out the format attributes */
ret = ast_format_get_value(format_def, SILK_ATTR_KEY_SAMP_RATE, &attr_samp_rate);
if(!ret) {
switch (attr_samp_rate) {
case SILK_ATTR_VAL_SAMP_8KHZ:
res |= ast_register_translator(&silk8tolin);
res |= ast_register_translator(&lintosilk8);
silk8_reg = 1;
break;
case SILK_ATTR_VAL_SAMP_12KHZ:
res |= ast_register_translator(&silk12tolin);
res |= ast_register_translator(&lintosilk12);
silk12_reg = 1;
break;
case SILK_ATTR_VAL_SAMP_16KHZ:
res |= ast_register_translator(&silk16tolin);
res |= ast_register_translator(&lintosilk16);
silk16_reg = 1;
break;
case SILK_ATTR_VAL_SAMP_24KHZ:
res |= ast_register_translator(&silk24tolin);
res |= ast_register_translator(&lintosilk24);
silk24_reg = 1;
break;
}
}
}
}
}
/* register the encoder / decoder */
if(res){
return AST_MODULE_LOAD_FAILURE;
}
return AST_MODULE_LOAD_SUCCESS;
}
