diff --git a/libs/silk/Makefile b/libs/silk/Makefile index 1daf976fae..4b723b40ea 100644 --- a/libs/silk/Makefile +++ b/libs/silk/Makefile @@ -27,7 +27,7 @@ cppflags-from-includes = $(addprefix -I,$(1)) ldflags-from-ldlibdirs = $(addprefix -L,$(1)) ldlibs-from-libs = $(addprefix -l,$(1)) -CFLAGS += -Wall -enable-threads -O3 +CFLAGS += -Wall -enable-threads -O3 -fPIC CFLAGS += $(call cppflags-from-defines,$(CDEFINES)) CFLAGS += $(call cppflags-from-includes,$(CINCLUDES)) diff --git a/src/mod/codecs/mod_silk/Makefile b/src/mod/codecs/mod_silk/Makefile new file mode 100644 index 0000000000..480f781bb4 --- /dev/null +++ b/src/mod/codecs/mod_silk/Makefile @@ -0,0 +1,8 @@ +BASE=../../../.. + +A=../../../../libs/silk/libSKP_SILK_SDK.a + +LOCAL_INSERT_CFLAGS=if test -f $(A); then echo "-I../../../../libs/silk/interface" ; else echo "-DNOTFOUND" ; fi ; +LOCAL_INSERT_LDFLAGS=test ! -f $(A) || echo $(A) + +include $(BASE)/build/modmake.rules diff --git a/src/mod/codecs/mod_silk/mod_silk.c b/src/mod/codecs/mod_silk/mod_silk.c new file mode 100644 index 0000000000..5834847471 --- /dev/null +++ b/src/mod/codecs/mod_silk/mod_silk.c @@ -0,0 +1,312 @@ +/* + * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * Copyright (C) 2005-2010, Anthony Minessale II + * + * Version: MPL 1.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * + * The Initial Developer of the Original Code is + * Anthony Minessale II + * Portions created by the Initial Developer are Copyright (C) + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Anthony Minessale II + * Brian K. West + * + * The silk codec itself is not distributed with this module. + * + * mod_silk.c -- Skype(tm) SILK Codec Module + * + */ + +#include "switch.h" +#include "SKP_Silk_SDK_API.h" + +SWITCH_MODULE_LOAD_FUNCTION(mod_silk_load); +SWITCH_MODULE_DEFINITION(mod_silk, mod_silk_load, NULL, NULL); + +#define MAX_BYTES_PER_FRAME 250 +#define MAX_INPUT_FRAMES 5 +#define MAX_LBRR_DELAY 2 +#define MAX_FRAME_LENGTH 480 + +struct silk_context { + SKP_SILK_SDK_EncControlStruct encoder_object; + SKP_SILK_SDK_DecControlStruct decoder_object; + void *enc_state; + void *dec_state; +}; + +static switch_status_t switch_silk_init(switch_codec_t *codec, switch_codec_flag_t freeswitch_flags, const switch_codec_settings_t *codec_settings) +{ + struct silk_context *context = NULL; + SKP_int useinbandfec = 0, usedtx = 0, maxaveragebitrate = 0; + SKP_int32 encSizeBytes; + SKP_int32 decSizeBytes; + int encoding = (freeswitch_flags & SWITCH_CODEC_FLAG_ENCODE); + int decoding = (freeswitch_flags & SWITCH_CODEC_FLAG_DECODE); + + if (!(encoding || decoding) + || (!(context = switch_core_alloc(codec->memory_pool, sizeof(*context))))) { + return SWITCH_STATUS_FALSE; + } + + if (codec->fmtp_in) { + int x, argc; + char *argv[10]; + argc = switch_separate_string(codec->fmtp_in, ';', argv, (sizeof(argv) / sizeof(argv[0]))); + for (x = 0; x < argc; x++) { + char *data = argv[x]; + char *arg; + switch_assert(data); + while (*data == ' ') { + data++; + } + if ((arg = strchr(data, '='))) { + *arg++ = '\0'; + if (!strcasecmp(data, "useinbandfec")) { + if (switch_true(arg)) { + useinbandfec = 1; + } + } + if (!strcasecmp(data, "usedtx")) { + if (switch_true(arg)) { + usedtx = 1; + } + } + if (!strcasecmp(data, "maxaveragebitrate")) { + maxaveragebitrate = atoi(arg); + switch (codec->implementation->actual_samples_per_second) { + case 8000: + { + if (maxaveragebitrate < 6000 || maxaveragebitrate > 20000) { + maxaveragebitrate = 20000; + } + break; + } + case 12000: + { + if (maxaveragebitrate < 7000 || maxaveragebitrate > 25000) { + maxaveragebitrate = 25000; + } + break; + } + case 16000: + { + if (maxaveragebitrate < 8000 || maxaveragebitrate > 30000) { + maxaveragebitrate = 30000; + } + break; + } + case 24000: + { + if (maxaveragebitrate < 12000 || maxaveragebitrate > 40000) { + maxaveragebitrate = 40000; + } + break; + } + + default: + /* this should never happen but 20000 is common among all rates */ + maxaveragebitrate = 20000; + break; + } + + } + } + } + } + + codec->fmtp_out = + switch_core_sprintf(codec->memory_pool, + "useinbandfec=%s; usedtx=%s; maxaveragebitrate=%d", + useinbandfec ? "true" : "false", + usedtx ? "true" : "false", maxaveragebitrate ? maxaveragebitrate : codec->implementation->bits_per_second); + + if (encoding) { + if (SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes)) { + return SWITCH_STATUS_FALSE; + } + + context->enc_state = switch_core_alloc(codec->memory_pool, encSizeBytes); + + if (SKP_Silk_SDK_InitEncoder(context->enc_state, &context->encoder_object)) { + return SWITCH_STATUS_FALSE; + } + + context->encoder_object.sampleRate = codec->implementation->actual_samples_per_second; + context->encoder_object.packetSize = codec->implementation->samples_per_packet; + context->encoder_object.useInBandFec = useinbandfec; + context->encoder_object.complexity = 2; + context->encoder_object.bitRate = maxaveragebitrate ? maxaveragebitrate : codec->implementation->bits_per_second; + context->encoder_object.useDtx = usedtx; + } + + if (decoding) { + if (SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes)) { + return SWITCH_STATUS_FALSE; + } + context->dec_state = switch_core_alloc(codec->memory_pool, decSizeBytes); + + if (SKP_Silk_SDK_InitDecoder(context->dec_state)) { + return SWITCH_STATUS_FALSE; + } + context->decoder_object.sampleRate = codec->implementation->actual_samples_per_second; + } + + codec->private_info = context; + + return SWITCH_STATUS_SUCCESS; +} + +static switch_status_t switch_silk_destroy(switch_codec_t *codec) +{ + codec->private_info = NULL; + return SWITCH_STATUS_SUCCESS; +} + + +static switch_status_t +switch_silk_encode(switch_codec_t *codec, + switch_codec_t *other_codec, + void *decoded_data, + uint32_t decoded_data_len, + uint32_t decoded_rate, void *encoded_data, uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag) +{ + struct silk_context *context = codec->private_info; + SKP_int16 ret; + SKP_int16 nBytes = MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES; + + ret = SKP_Silk_SDK_Encode(context->enc_state, &context->encoder_object, decoded_data, (SKP_int16) decoded_data_len / 2, encoded_data, &nBytes); + + if (ret) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SKP_Silk_Encode returned %d!\n", ret); + } + + *encoded_data_len = nBytes; + + return SWITCH_STATUS_SUCCESS; +} + +static switch_status_t +switch_silk_decode(switch_codec_t *codec, + switch_codec_t *other_codec, + void *encoded_data, + uint32_t encoded_data_len, + uint32_t encoded_rate, void *decoded_data, uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag) +{ + struct silk_context *context = codec->private_info; + SKP_int16 ret, len; + int16_t *target = decoded_data; + + *decoded_data_len = 0; + + do { + ret = SKP_Silk_SDK_Decode(context->dec_state, &context->decoder_object, ((*flag & SFF_PLC)), encoded_data, encoded_data_len, target, &len); + if (ret) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SKP_Silk_Decode returned %d!\n", ret); + } + + target += len; + *decoded_data_len += (len * 2); + } + while (context->decoder_object.internalDecoderFrames); + + return SWITCH_STATUS_SUCCESS; +} + +SWITCH_MODULE_LOAD_FUNCTION(mod_silk_load) +{ + switch_codec_interface_t *codec_interface; + *module_interface = switch_loadable_module_create_module_interface(pool, modname); + + SWITCH_ADD_CODEC(codec_interface, "SILK"); + switch_core_codec_add_implementation(pool, codec_interface, SWITCH_CODEC_TYPE_AUDIO, /* enumeration defining the type of the codec */ + 117, /* the IANA code number */ + "SILK", /* the IANA code name */ + "useinbandfec=false; usedtx=false", /* default fmtp to send (can be overridden by the init function) */ + 8000, /* samples transferred per second */ + 8000, /* actual samples transferred per second */ + 20000, /* bits transferred per second */ + 20000, /* number of microseconds per frame */ + 160, /* number of samples per frame */ + 320, /* number of bytes per frame decompressed */ + 0, /* number of bytes per frame compressed */ + 1, /* number of channels represented */ + 1, /* number of frames per network packet */ + switch_silk_init, /* function to initialize a codec handle using this implementation */ + switch_silk_encode, /* function to encode raw data into encoded data */ + switch_silk_decode, /* function to decode encoded data into raw data */ + switch_silk_destroy); /* deinitalize a codec handle using this implementation */ + + switch_core_codec_add_implementation(pool, codec_interface, SWITCH_CODEC_TYPE_AUDIO, /* enumeration defining the type of the codec */ + 118, /* the IANA code number */ + "SILK", /* the IANA code name */ + "useinbandfec=false; usedtx=false", /* default fmtp to send (can be overridden by the init function) */ + 12000, /* samples transferred per second */ + 12000, /* actual samples transferred per second */ + 25000, /* bits transferred per second */ + 20000, /* number of microseconds per frame */ + 240, /* number of samples per frame */ + 480, /* number of bytes per frame decompressed */ + 0, /* number of bytes per frame compressed */ + 1, /* number of channels represented */ + 1, /* number of frames per network packet */ + switch_silk_init, /* function to initialize a codec handle using this implementation */ + switch_silk_encode, /* function to encode raw data into encoded data */ + switch_silk_decode, /* function to decode encoded data into raw data */ + switch_silk_destroy); /* deinitalize a codec handle using this implementation */ + + switch_core_codec_add_implementation(pool, codec_interface, SWITCH_CODEC_TYPE_AUDIO, /* enumeration defining the type of the codec */ + 119, /* the IANA code number */ + "SILK", /* the IANA code name */ + "useinbandfec=false; usedtx=false", /* default fmtp to send (can be overridden by the init function) */ + 16000, /* samples transferred per second */ + 16000, /* actual samples transferred per second */ + 30000, /* bits transferred per second */ + 20000, /* number of microseconds per frame */ + 320, /* number of samples per frame */ + 640, /* number of bytes per frame decompressed */ + 0, /* number of bytes per frame compressed */ + 1, /* number of channels represented */ + 1, /* number of frames per network packet */ + switch_silk_init, /* function to initialize a codec handle using this implementation */ + switch_silk_encode, /* function to encode raw data into encoded data */ + switch_silk_decode, /* function to decode encoded data into raw data */ + switch_silk_destroy); /* deinitalize a codec handle using this implementation */ + + switch_core_codec_add_implementation(pool, codec_interface, SWITCH_CODEC_TYPE_AUDIO, /* enumeration defining the type of the codec */ + 120, /* the IANA code number */ + "SILK", /* the IANA code name */ + "useinbandfec=false; usedtx=false", /* default fmtp to send (can be overridden by the init function) */ + 24000, /* samples transferred per second */ + 24000, /* actual samples transferred per second */ + 40000, /* bits transferred per second */ + 20000, /* number of microseconds per frame */ + 480, /* number of samples per frame */ + 960, /* number of bytes per frame decompressed */ + 0, /* number of bytes per frame compressed */ + 1, /* number of channels represented */ + 1, /* number of frames per network packet */ + switch_silk_init, /* function to initialize a codec handle using this implementation */ + switch_silk_encode, /* function to encode raw data into encoded data */ + switch_silk_decode, /* function to decode encoded data into raw data */ + switch_silk_destroy); /* deinitalize a codec handle using this implementation */ + + + /* indicate that the module should continue to be loaded */ + return SWITCH_STATUS_SUCCESS; +}