switch_speex.c File Reference

#include <switch.h>
#include <speex/speex.h>
#include <speex/speex_preprocess.h>

Include dependency graph for switch_speex.c:

Go to the source code of this file.

Data Structures
struct	speex_codec_settings
	Various codec settings (currently only relevant to speex) More...
struct	speex_context

Typedefs
typedef struct speex_codec_settings	speex_codec_settings_t

Functions
	SWITCH_MODULE_LOAD_FUNCTION (core_speex_load)
	SWITCH_MODULE_DEFINITION (CORE_SPEEX_MODULE, core_speex_load, NULL, NULL)
static switch_status_t	switch_speex_fmtp_parse (const char *fmtp, switch_codec_fmtp_t *codec_fmtp)
static switch_status_t	switch_speex_init (switch_codec_t *codec, switch_codec_flag_t flags, const switch_codec_settings_t *codec_settings)
static switch_status_t	switch_speex_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)
static switch_status_t	switch_speex_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)
static switch_status_t	switch_speex_destroy (switch_codec_t *codec)
static void	load_configuration (void)

Variables
static speex_codec_settings_t	default_codec_settings

Typedef Documentation

speex_codec_settings_t

typedef struct speex_codec_settings speex_codec_settings_t

Definition at line 82 of file switch_speex.c.

Function Documentation

load_configuration()

static void load_configuration ( void  )

static

read default settings from speex.conf

Definition at line 473 of file switch_speex.c.

References speex_codec_settings::abr, speex_codec_settings::complexity, speex_codec_settings::dtx, speex_codec_settings::enhancement, name, switch_xml::next, speex_codec_settings::pp_agc, speex_codec_settings::pp_agc_level, speex_codec_settings::pp_denoise, speex_codec_settings::pp_dereverb, speex_codec_settings::pp_dereverb_decay, speex_codec_settings::pp_dereverb_level, speex_codec_settings::pp_vad, speex_codec_settings::preproc, speex_codec_settings::quality, SWITCH_CHANNEL_LOG, switch_is_number(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_true(), switch_xml_attr(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), speex_codec_settings::vad, value, speex_codec_settings::vbr, speex_codec_settings::vbr_quality, and zstr.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        switch_xml_t xml = NULL, cfg = NULL;

        if ((xml = switch_xml_open_cfg("speex.conf", &cfg, NULL))) {
                switch_xml_t x_lists;
                if ((x_lists = switch_xml_child(cfg, "settings"))) {
                        const char *settings_name = switch_xml_attr(x_lists, "name");
                        switch_xml_t x_list;
                        if (zstr(settings_name)) {
                                settings_name = "";
                        }
                        for (x_list = switch_xml_child(x_lists, "param"); x_list; x_list = x_list->next) {
                                const char *name = switch_xml_attr(x_list, "name");
                                const char *value = switch_xml_attr(x_list, "value");
                                if (zstr(name)) {
                                        continue;
                                }

                                if (zstr(value)) {
                                        continue;
                                }

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s %s = %s\n", settings_name, name, value);

                                if (!strcasecmp("quality", name)) {
                                        /* compression quality, integer 0-10 */
                                        int tmp = atoi(value);
                                        if (switch_is_number(value) && tmp >= 0 && tmp <= 10) {
                                                default_codec_settings.quality = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid quality value: %s\n", value);
                                        }
                                } else if (!strcasecmp("complexity", name)) {
                                        /* compression complexity, integer 1-10 */
                                        int tmp = atoi(value);
                                        if (switch_is_number(value) && tmp >= 1 && tmp <= 10) {
                                                default_codec_settings.complexity = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid complexity value: %s\n", value);
                                        }
                                } else if (!strcasecmp("enhancement", name)) {
                                        /* enable perceptual enhancement, boolean */
                                        default_codec_settings.enhancement = switch_true(value);
                                } else if (!strcasecmp("vad", name)) {
                                        /* enable voice activity detection, boolean */
                                        default_codec_settings.vad = switch_true(value);
                                } else if (!strcasecmp("vbr", name)) {
                                        /* enable variable bit rate, boolean */
                                        default_codec_settings.vbr = switch_true(value);
                                } else if (!strcasecmp("vbr-quality", name)) {
                                        /* variable bit rate quality, float 0-10 */
                                        float tmp = (float)atof(value);
                                        if (switch_is_number(value) && tmp >= 0 && tmp <= 10) {
                                                default_codec_settings.vbr_quality = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid vbr-quality value: %s\n", value);
                                        }
                                } else if (!strcasecmp("abr", name)) {
                                        /* average bit rate, integer bits per sec */
                                        int tmp = atoi(value);
                                        if (switch_is_number(value) && tmp >= 0) {
                                                default_codec_settings.abr = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid abr value: %s\n", value);
                                        }
                                } else if (!strcasecmp("dtx", name)) {
                                        /* discontinuous transmit, boolean */
                                        default_codec_settings.dtx = switch_true(value);
                                } else if (!strcasecmp("preproc", name)) {
                                        /* enable preprocessor, boolean */
                                        default_codec_settings.preproc = switch_true(value);
                                } else if (!strcasecmp("pp-vad", name)) {
                                        /* enable preprocessor VAD, boolean */
                                        default_codec_settings.pp_vad = switch_true(value);
                                } else if (!strcasecmp("pp-agc", name)) {
                                        /* enable preprocessor automatic gain control, boolean */
                                        default_codec_settings.pp_agc = switch_true(value);
                                } else if (!strcasecmp("pp-agc-level", name)) {
                                        /* agc level, float */
                                        float tmp = (float)atof(value);
                                        if (switch_is_number(value) && tmp >= 0.0f) {
                                                default_codec_settings.pp_agc_level = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid pp-agc-level value: %s\n", value);
                                        }
                                } else if (!strcasecmp("pp-denoise", name)) {
                                        /* enable preprocessor denoiser, boolean */
                                        default_codec_settings.pp_denoise = switch_true(value);
                                } else if (!strcasecmp("pp-dereverb", name)) {
                                        /* enable preprocessor reverberation removal, boolean */
                                        default_codec_settings.pp_dereverb = switch_true(value);
                                } else if (!strcasecmp("pp-dereverb-decay", name)) {
                                        /* reverberation removal decay, float */
                                        float tmp = (float)atof(value);
                                        if (switch_is_number(value) && tmp >= 0.0f) {
                                                default_codec_settings.pp_dereverb_decay = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid pp-dereverb-decay value: %s\n", value);
                                        }
                                } else if (!strcasecmp("pp-dereverb-level", name)) {
                                        /* reverberation removal level, float */
                                        float tmp = (float)atof(value);
                                        if (switch_is_number(value) && tmp >= 0.0f) {
                                                default_codec_settings.pp_dereverb_level = tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid pp-dereverb-level value: %s\n", value);
                                        }
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ignoring invalid unknown param: %s = %s\n", name, value);
                                }
                        }
                }
                switch_xml_free(xml);
        }
}

SWITCH_MODULE_DEFINITION()

SWITCH_MODULE_DEFINITION	(	CORE_SPEEX_MODULE	,
		core_speex_load	,
		NULL	,
		NULL
	)

SWITCH_MODULE_LOAD_FUNCTION()

SWITCH_MODULE_LOAD_FUNCTION

(

core_speex_load

)

Definition at line 590 of file switch_speex.c.

References load_configuration(), switch_codec_interface::parse_fmtp, pool, SWITCH_ADD_CODEC, SWITCH_CODEC_TYPE_AUDIO, switch_core_codec_add_implementation(), switch_loadable_module_create_module_interface(), switch_speex_decode(), switch_speex_destroy(), switch_speex_encode(), switch_speex_fmtp_parse(), switch_speex_init(), and SWITCH_STATUS_SUCCESS.

{
        switch_codec_interface_t *codec_interface;
        int mpf = 20000, spf = 160, bpf = 320, rate = 8000, counta, countb;
        switch_payload_t ianacode[4] = { 0, 99, 99, 99 };
        int bps[4] = { 0, 24600, 42200, 44000 };
        /* connect my internal structure to the blank pointer passed to me */
        *module_interface = switch_loadable_module_create_module_interface(pool, modname);

        load_configuration();

        SWITCH_ADD_CODEC(codec_interface, "Speex");
        codec_interface->parse_fmtp = switch_speex_fmtp_parse;
        for (counta = 1; counta <= 3; counta++) {
                for (countb = 1; countb > 0; countb--) {
                        switch_core_codec_add_implementation(pool, codec_interface, SWITCH_CODEC_TYPE_AUDIO,    /* enumeration defining the type of the codec */
                                                                                                 ianacode[counta],      /* the IANA code number */
                                                                                                 "SPEEX",       /* the IANA code name */
                                                                                                 NULL,  /* default fmtp to send (can be overridden by the init function) */
                                                                                                 rate,  /* samples transferred per second */
                                                                                                 rate,  /* actual samples transferred per second */
                                                                                                 bps[counta],   /* bits transferred per second */
                                                                                                 mpf * countb,  /* number of microseconds per frame */
                                                                                                 spf * countb,  /* number of samples per frame */
                                                                                                 bpf * countb,  /* 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_speex_init,     /* function to initialize a codec handle using this implementation */
                                                                                                 switch_speex_encode,   /* function to encode raw data into encoded data */
                                                                                                 switch_speex_decode,   /* function to decode encoded data into raw data */
                                                                                                 switch_speex_destroy); /* deinitalize a codec handle using this implementation */
                }
                rate = rate * 2;
                spf = spf * 2;
                bpf = bpf * 2;
        }




        /* indicate that the module should continue to be loaded */
        return SWITCH_STATUS_SUCCESS;
}

switch_speex_decode()

static switch_status_t switch_speex_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  )

static

Definition at line 416 of file switch_speex.c.

References buf, switch_codec_implementation::decoded_bytes_per_packet, speex_context::decoder_bits, speex_context::decoder_state, switch_codec::implementation, switch_codec::private_info, SWITCH_CODEC_FLAG_SILENCE, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        struct speex_context *context = codec->private_info;
        short *buf;

        if (!context) {
                return SWITCH_STATUS_FALSE;
        }


        buf = decoded_data;
        if (*flag & SWITCH_CODEC_FLAG_SILENCE) {
                speex_decode_int(context->decoder_state, NULL, buf);
        } else {
                speex_bits_read_from(&context->decoder_bits, (char *) encoded_data, (int) encoded_data_len);
                speex_decode_int(context->decoder_state, &context->decoder_bits, buf);
        }
        *decoded_data_len = codec->implementation->decoded_bytes_per_packet;

        return SWITCH_STATUS_SUCCESS;
}

switch_speex_destroy()

static switch_status_t switch_speex_destroy ( switch_codec_t *  codec )

static

Definition at line 443 of file switch_speex.c.

References speex_context::decoder_bits, speex_context::decoder_state, speex_context::encoder_bits, speex_context::encoder_state, switch_codec::flags, switch_codec::private_info, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        int encoding, decoding;
        struct speex_context *context = codec->private_info;

        if (!context) {
                return SWITCH_STATUS_FALSE;
        }

        encoding = (codec->flags & SWITCH_CODEC_FLAG_ENCODE);
        decoding = (codec->flags & SWITCH_CODEC_FLAG_DECODE);

        if (encoding) {
                speex_bits_destroy(&context->encoder_bits);
                speex_encoder_destroy(context->encoder_state);
        }

        if (decoding) {
                speex_bits_destroy(&context->decoder_bits);
                speex_decoder_destroy(context->decoder_state);
        }

        codec->private_info = NULL;

        return SWITCH_STATUS_SUCCESS;
}

switch_speex_encode()

static switch_status_t switch_speex_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  )

static

Definition at line 365 of file switch_speex.c.

References buf, speex_context::codec_settings, speex_codec_settings::dtx, speex_context::encoder_bits, speex_context::encoder_frame_size, speex_context::encoder_state, speex_context::pp, switch_codec::private_info, SFF_CNG, switch_clear_flag, SWITCH_CODEC_FLAG_SILENCE, switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        struct speex_context *context = codec->private_info;
        short *buf;
        int is_speech = 1;

        if (!context) {
                return SWITCH_STATUS_FALSE;
        }

        buf = decoded_data;

        if (context->pp) {
                is_speech = speex_preprocess(context->pp, buf, NULL);
        }

        if (is_speech) {
                is_speech = speex_encode_int(context->encoder_state, buf, &context->encoder_bits)
                        || !context->codec_settings.dtx;
        } else {
                speex_bits_pack(&context->encoder_bits, 0, 5);
        }


        if (is_speech) {
                switch_clear_flag(context, SWITCH_CODEC_FLAG_SILENCE);
                *flag &= ~SFF_CNG;
        } else {
                if (switch_test_flag(context, SWITCH_CODEC_FLAG_SILENCE)) {
                        *encoded_data_len = 0;
                        *flag |= SFF_CNG;
                        return SWITCH_STATUS_SUCCESS;
                }

                switch_set_flag(context, SWITCH_CODEC_FLAG_SILENCE);
        }


        speex_bits_pack(&context->encoder_bits, 15, 5);
        *encoded_data_len = speex_bits_write(&context->encoder_bits, (char *) encoded_data, context->encoder_frame_size);
        speex_bits_reset(&context->encoder_bits);
        (*encoded_data_len)--;

        return SWITCH_STATUS_SUCCESS;
}

switch_speex_fmtp_parse()

static switch_status_t switch_speex_fmtp_parse ( const char *  fmtp, switch_codec_fmtp_t *  codec_fmtp  )

static

Definition at line 122 of file switch_speex.c.

References switch_codec_fmtp::actual_samples_per_second, mode, speex_codec_settings::pp_vad, switch_codec_fmtp::private_info, speex_codec_settings::quality, switch_assert, SWITCH_CHANNEL_LOG, switch_is_number(), SWITCH_LOG_DEBUG1, switch_log_printf(), switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), speex_codec_settings::vad, speex_codec_settings::vbr, speex_codec_settings::vbr_quality, and zstr.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), and switch_speex_init().

{
        speex_codec_settings_t *codec_settings = NULL;
        int x, argc;
        char *argv[10];
        char *fmtp_dup = NULL;

        if (!codec_fmtp) {
                return SWITCH_STATUS_FALSE;
        }

        /* load default settings */
        if (codec_fmtp->private_info) {
                codec_settings = codec_fmtp->private_info;
                memcpy(codec_settings, &default_codec_settings, sizeof(*codec_settings));
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "codec_fmtp->private_info is NULL\n");
                return SWITCH_STATUS_SUCCESS;
        }

        if (!fmtp) {
                return SWITCH_STATUS_SUCCESS;
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "got fmtp: %s\n", fmtp);

        fmtp_dup = strdup(fmtp);
        switch_assert(fmtp_dup);

        /* parse ; separated fmtp args */
        argc = switch_separate_string(fmtp_dup, ';', 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, '='))) {
                        continue;
                }
                *arg++ = '\0';
                if (zstr(arg)) {
                        continue;
                }

                if (!strcasecmp("vbr", data)) {
                        /* vbr can be on/off/vad */
                        if (!strcasecmp("vad", arg)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "enabling speex vbr=vad\n");
                                codec_settings->vbr = 0;
                                codec_settings->vad = 1;
                                codec_settings->pp_vad = 1;
                        } else {
                                if (switch_true(arg)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "enabling speex vbr\n");
                                        codec_settings->vbr = 1;
                                        codec_settings->vad = 0;
                                        codec_settings->pp_vad = 1;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "disabling speex vbr\n");
                                        codec_settings->vbr = 0;
                                        codec_settings->vad = 0;
                                        codec_settings->pp_vad = 0;
                                }
                        }
                } else if (!strcasecmp("cng", data)) {
                        /* TODO don't know how to turn on CNG */
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "speex cng is unsupported\n");
                } else if (!strcasecmp("mode", data)) {
                        /* mode is a comma-separate list of preferred modes.  Use the first mode in the list */
                        char *arg_dup;
                        char *mode[2];
                        if (!strncasecmp("any", arg, 3)) {
                                /* "any", keep the default setting */
                                continue;
                        }
                        arg_dup = strdup(arg);
                        if (switch_separate_string(arg_dup, ',', mode, (sizeof(mode) / sizeof(mode[0])))) {
                                int mode_num = -1;
                                char *mode_str = mode[0];
                                if (mode_str[0] == '"') {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "mode starts with \"\n");
                                        mode_str++;
                                }
                                if (switch_is_number(mode_str)) {
                                        mode_num = atoi(mode_str);
                                }
                                /* TODO there might be a way to set the mode directly instead of changing the quality */
                                if (codec_fmtp->actual_samples_per_second == 8000) {
                                        switch (mode_num) {
                                        case 1:
                                                codec_settings->quality = 0;
                                                break;
                                        case 2:
                                                codec_settings->quality = 2;
                                                break;
                                        case 3:
                                                codec_settings->quality = 4;
                                                break;
                                        case 4:
                                                codec_settings->quality = 6;
                                                break;
                                        case 5:
                                                codec_settings->quality = 8;
                                                break;
                                        case 6:
                                                codec_settings->quality = 9;
                                                break;
                                        case 7:
                                                codec_settings->quality = 10;
                                                break;
                                        case 8:
                                                codec_settings->quality = 1;
                                                break;
                                        default:
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "ignoring invalid speex/8000 mode %s\n", mode_str);
                                                continue;
                                        }
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "choosing speex/8000 mode %s\n", mode_str);
                                        codec_settings->vbr_quality = (float)codec_settings->quality;
                                } else {
                                        if (mode_num >= 0 && mode_num <= 10) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "choosing speex/%d mode %s\n", codec_fmtp->actual_samples_per_second, mode_str);
                                                codec_settings->quality = mode_num;
                                                codec_settings->vbr_quality = (float)mode_num;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "ignoring invalid speex/%d mode %s\n", codec_fmtp->actual_samples_per_second, mode_str);
                                                continue;
                                        }
                                }
                        }
                        free(arg_dup);
                }
        }
        free(fmtp_dup);
        /*codec_fmtp->bits_per_second = bit_rate;*/
        return SWITCH_STATUS_SUCCESS;
}

switch_speex_init()

static switch_status_t switch_speex_init ( switch_codec_t *  codec, switch_codec_flag_t  flags, const switch_codec_settings_t *  codec_settings  )

static

Definition at line 263 of file switch_speex.c.

References speex_codec_settings::abr, switch_codec_fmtp::actual_samples_per_second, switch_codec_implementation::actual_samples_per_second, speex_context::codec, speex_context::codec_settings, speex_codec_settings::complexity, speex_context::decoder_bits, speex_context::decoder_state, speex_codec_settings::dtx, speex_context::encoder_bits, speex_context::encoder_frame_size, speex_context::encoder_state, speex_codec_settings::enhancement, switch_codec::fmtp_in, switch_codec::implementation, switch_codec::memory_pool, memset(), mode, speex_context::pp, speex_codec_settings::pp_agc, speex_codec_settings::pp_agc_level, speex_codec_settings::pp_denoise, speex_codec_settings::pp_dereverb, speex_codec_settings::pp_dereverb_decay, speex_codec_settings::pp_dereverb_level, speex_codec_settings::pp_vad, speex_codec_settings::preproc, switch_codec_fmtp::private_info, switch_codec::private_info, speex_codec_settings::quality, SWITCH_CHANNEL_LOG, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_alloc, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_speex_fmtp_parse(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, speex_codec_settings::vad, speex_codec_settings::vbr, and speex_codec_settings::vbr_quality.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        struct speex_context *context = NULL;
        int encoding, decoding;

        encoding = (flags & SWITCH_CODEC_FLAG_ENCODE);
        decoding = (flags & SWITCH_CODEC_FLAG_DECODE);

        if (!(encoding || decoding) || ((context = switch_core_alloc(codec->memory_pool, sizeof(*context))) == 0)) {
                return SWITCH_STATUS_FALSE;
        } else {
                const SpeexMode *mode = NULL;
                switch_codec_fmtp_t codec_fmtp;
                speex_codec_settings_t codec_settings;

                memset(&codec_fmtp, '\0', sizeof(struct switch_codec_fmtp));
                codec_fmtp.private_info = &codec_settings;
                codec_fmtp.actual_samples_per_second = codec->implementation->actual_samples_per_second;
                switch_speex_fmtp_parse(codec->fmtp_in, &codec_fmtp);

                memcpy(&context->codec_settings, &codec_settings, sizeof(context->codec_settings));

                context->codec = codec;
                if (codec->implementation->actual_samples_per_second == 8000) {
                        mode = &speex_nb_mode;
                } else if (codec->implementation->actual_samples_per_second == 16000) {
                        mode = &speex_wb_mode;
                } else if (codec->implementation->actual_samples_per_second == 32000) {
                        mode = &speex_uwb_mode;
                }

                if (!mode) {
                        return SWITCH_STATUS_FALSE;
                }

                if (encoding) {
                        speex_bits_init(&context->encoder_bits);
                        context->encoder_state = speex_encoder_init(mode);
                        speex_encoder_ctl(context->encoder_state, SPEEX_GET_FRAME_SIZE, &context->encoder_frame_size);
                        speex_encoder_ctl(context->encoder_state, SPEEX_SET_COMPLEXITY, &context->codec_settings.complexity);
                        if (context->codec_settings.preproc) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "preprocessor on\n");
                                context->pp = speex_preprocess_state_init(context->encoder_frame_size, codec->implementation->actual_samples_per_second);
                                if (context->codec_settings.pp_vad) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "preprocessor vad on\n");
                                }
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_VAD, &context->codec_settings.pp_vad);
                                if (context->codec_settings.pp_agc) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "preprocessor agc on\n");
                                }
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_AGC, &context->codec_settings.pp_agc);
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &context->codec_settings.pp_agc_level);
                                if (context->codec_settings.pp_denoise) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "preprocessor denoise on\n");
                                }
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_DENOISE, &context->codec_settings.pp_denoise);
                                if (context->codec_settings.pp_dereverb) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "preprocessor dereverb on\n");
                                }
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_DEREVERB, &context->codec_settings.pp_dereverb);
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &context->codec_settings.pp_dereverb_decay);
                                speex_preprocess_ctl(context->pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &context->codec_settings.pp_dereverb_level);
                        }

                        if (!context->codec_settings.abr && !context->codec_settings.vbr) {
                                speex_encoder_ctl(context->encoder_state, SPEEX_SET_QUALITY, &context->codec_settings.quality);
                                if (context->codec_settings.vad) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "vad on\n");
                                        speex_encoder_ctl(context->encoder_state, SPEEX_SET_VAD, &context->codec_settings.vad);
                                }
                        }
                        if (context->codec_settings.vbr) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "vbr on\n");
                                speex_encoder_ctl(context->encoder_state, SPEEX_SET_VBR, &context->codec_settings.vbr);
                                speex_encoder_ctl(context->encoder_state, SPEEX_SET_VBR_QUALITY, &context->codec_settings.vbr_quality);
                        }
                        if (context->codec_settings.abr) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "abr on\n");
                                speex_encoder_ctl(context->encoder_state, SPEEX_SET_ABR, &context->codec_settings.abr);
                        }
                        if (context->codec_settings.dtx) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "dtx on\n");
                                speex_encoder_ctl(context->encoder_state, SPEEX_SET_DTX, &context->codec_settings.dtx);
                        }
                }

                if (decoding) {
                        speex_bits_init(&context->decoder_bits);
                        context->decoder_state = speex_decoder_init(mode);
                        if (context->codec_settings.enhancement) {
                                speex_decoder_ctl(context->decoder_state, SPEEX_SET_ENH, &context->codec_settings.enhancement);
                        }
                }



                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "initialized Speex codec \n");
                codec->private_info = context;
                return SWITCH_STATUS_SUCCESS;
        }
}

Variable Documentation

default_codec_settings

speex_codec_settings_t default_codec_settings

static

Initial value:

= {
         5,
         5,
         1,
         0,
         0,
         4,
         0,
         0,
         0,
         0,
         0,
         8000,
         0,
         0,
         0.4f,
         0.3f,
}

Definition at line 84 of file switch_speex.c.