switch_resample.c File Reference

#include <switch.h>
#include <switch_resample.h>
#include <switch_private.h>
#include <speex/speex_resampler.h>

Include dependency graph for switch_resample.c:

Go to the source code of this file.

Data Structures
struct	switch_agc_s

Macros
#define	NORMFACT   (float)0x8000
#define	MAXSAMPLE   (float)0x7FFF
#define	MAXSAMPLEC   (char)0x7F
#define	QUALITY   0
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	resample_buffer(a, b, c)   a > b ? ((a / 1000) / 2) * c : ((b / 1000) / 2) * c

Functions
switch_status_t	switch_resample_perform_create (switch_audio_resampler_t **new_resampler, uint32_t from_rate, uint32_t to_rate, uint32_t to_size, int quality, uint32_t channels, const char *file, const char *func, int line)
	Prepare a new resampler handle. More...
uint32_t	switch_resample_process (switch_audio_resampler_t *resampler, int16_t *src, uint32_t srclen)
	Resample one float buffer into another using specifications of a given handle. More...
void	switch_resample_destroy (switch_audio_resampler_t **resampler)
	Destroy an existing resampler handle. More...
switch_size_t	switch_float_to_short (float *f, short *s, switch_size_t len)
	Convert an array of floats to an array of shorts. More...
int	switch_char_to_float (char *c, float *f, int len)
	Convert an array of chars to an array of floats. More...
int	switch_float_to_char (float *f, char *c, int len)
	Convert an array of floats to an array of chars. More...
int	switch_short_to_float (short *s, float *f, int len)
	Convert an array of shorts to an array of floats. More...
void	switch_swap_linear (int16_t *buf, int len)
	Perform a byteswap on a buffer of 16 bit samples. More...
void	switch_generate_sln_silence (int16_t *data, uint32_t samples, uint32_t channels, uint32_t divisor)
	Generate static noise. More...
uint32_t	switch_merge_sln (int16_t *data, uint32_t samples, int16_t *other_data, uint32_t other_samples, int channels)
uint32_t	switch_unmerge_sln (int16_t *data, uint32_t samples, int16_t *other_data, uint32_t other_samples, int channels)
void	switch_mux_channels (int16_t *data, switch_size_t samples, uint32_t orig_channels, uint32_t channels)
void	switch_change_sln_volume_granular (int16_t *data, uint32_t samples, int32_t vol)
	Change the volume of a signed linear audio frame with more granularity. More...
void	switch_change_sln_volume (int16_t *data, uint32_t samples, int32_t vol)
	Change the volume of a signed linear audio frame. More...
void	switch_agc_set (switch_agc_t *agc, uint32_t energy_avg, uint32_t low_energy_point, uint32_t margin, uint32_t change_factor, uint32_t period_len)
switch_status_t	switch_agc_create (switch_agc_t **agcP, uint32_t energy_avg, uint32_t low_energy_point, uint32_t margin, uint32_t change_factor, uint32_t period_len)
void	switch_agc_destroy (switch_agc_t **agcP)
void	switch_agc_set_energy_avg (switch_agc_t *agc, uint32_t energy_avg)
void	switch_agc_set_energy_low (switch_agc_t *agc, uint32_t low_energy_point)
void	switch_agc_set_token (switch_agc_t *agc, const char *token)
switch_status_t	switch_agc_feed (switch_agc_t *agc, int16_t *data, uint32_t samples, uint32_t channels)

Macro Definition Documentation

MAX

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 50 of file switch_resample.c.

MAXSAMPLE

#define MAXSAMPLE   (float)0x7FFF

Definition at line 41 of file switch_resample.c.

Referenced by switch_char_to_float(), and switch_float_to_short().

MAXSAMPLEC

#define MAXSAMPLEC   (char)0x7F

Definition at line 42 of file switch_resample.c.

MIN

#define MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 46 of file switch_resample.c.

NORMFACT

#define NORMFACT   (float)0x8000

Definition at line 40 of file switch_resample.c.

Referenced by switch_char_to_float(), switch_float_to_char(), switch_float_to_short(), and switch_short_to_float().

QUALITY

#define QUALITY   0

Definition at line 43 of file switch_resample.c.

resample_buffer

#define resample_buffer	(		a,
			b,
			c
	)		a > b ? ((a / 1000) / 2) * c : ((b / 1000) / 2) * c

Definition at line 53 of file switch_resample.c.

Function Documentation

switch_agc_create()

switch_status_t switch_agc_create	(	switch_agc_t **	agcP,
		uint32_t	energy_avg,
		uint32_t	low_energy_point,
		uint32_t	margin,
		uint32_t	change_factor,
		uint32_t	period_len
	)

Definition at line 470 of file switch_resample.c.

References switch_agc_s::pool, switch_agc_set(), switch_agc_set_token(), switch_assert, switch_core_alloc, switch_core_new_memory_pool, switch_snprintf(), and SWITCH_STATUS_SUCCESS.

{
        switch_agc_t *agc;
        switch_memory_pool_t *pool;
        char id[80] = "";

        switch_assert(agcP);

        switch_core_new_memory_pool(&pool);
        
        agc = switch_core_alloc(pool, sizeof(*agc));
        agc->pool = pool;

        switch_agc_set(agc, energy_avg, low_energy_point, margin, change_factor, period_len);


        switch_snprintf(id, sizeof(id), "%p", (void *)agc);
        switch_agc_set_token(agc, id);

        *agcP = agc;

        return SWITCH_STATUS_SUCCESS;
}

switch_agc_destroy()

void switch_agc_destroy

(

switch_agc_t **

agcP

)

Definition at line 495 of file switch_resample.c.

References switch_agc_s::pool, switch_assert, and switch_core_destroy_memory_pool.

{
        switch_agc_t *agc;

        switch_assert(agcP);

        agc = *agcP;
        *agcP = NULL;

        if (agc) {
                switch_memory_pool_t *pool = agc->pool;
                switch_core_destroy_memory_pool(&pool);
        }
}

switch_agc_feed()

switch_status_t switch_agc_feed	(	switch_agc_t *	agc,
		int16_t *	data,
		uint32_t	samples,
		uint32_t	channels
	)

Definition at line 529 of file switch_resample.c.

References switch_agc_s::change_factor, switch_agc_s::energy_avg, switch_agc_s::low_energy_point, switch_agc_s::margin, switch_agc_s::period_len, switch_agc_s::score, switch_agc_s::score_avg, switch_agc_s::score_count, switch_agc_s::score_over, switch_agc_s::score_sum, switch_agc_s::score_under, switch_change_sln_volume_granular(), SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_normalize_volume_granular, SWITCH_STATUS_SUCCESS, switch_agc_s::token, and switch_agc_s::vol.

{
        
        if (!channels) channels = 1;

        if (agc->vol) {
                switch_change_sln_volume_granular(data, samples * channels, agc->vol);
        }
                                                        
        if (agc->energy_avg) {
                uint32_t energy = 0;
                int i;

                for (i = 0; i < samples * channels; i++) {
                        energy += abs(data[i]);
                }

                if (samples) { 
                        agc->score = energy / samples * channels;
                }
                agc->score_sum += agc->score;
                agc->score_count++;
                                                                
                if (agc->score_count > agc->period_len) {
                                                                        
                        agc->score_avg = (int)((double)agc->score_sum / agc->score_count);
                        agc->score_count = 0;
                        agc->score_sum = 0;
                                                                        
                        if (agc->score_avg > agc->energy_avg) {
                                if (agc->score_avg - agc->energy_avg > agc->margin) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] OVER++ SCORE AVG: %d ENERGY AVG: %d MARGIN: %d\n", 
                                                                          agc->token, agc->score_avg, agc->energy_avg, agc->margin);
                                        agc->score_over++;
                                } else {
                                        agc->score_over = 0;
                                }
                        } else {
                                agc->score_over = 0;
                        }

                        if (agc->score_avg < agc->low_energy_point) {
                                agc->score_under = agc->change_factor + 1;
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] BELOW LOW POINT, SCORE AVG: %d ENERGY AVG: %d MARGIN: %d\n", 
                                                                  agc->token, agc->score_avg, agc->energy_avg, agc->margin);
                        } else if (((agc->score_avg < agc->energy_avg) && (agc->energy_avg - agc->score_avg > agc->margin))) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] UNDER++ SCORE AVG: %d ENERGY AVG: %d MARGIN: %d\n", 
                                                                  agc->token, agc->score_avg, agc->energy_avg, agc->margin);
                                agc->score_under++;
                        } else {
                                agc->score_under = 0;
                        }

                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] AVG %d over: %d under: %d\n", 
                                                          agc->token, agc->score_avg, agc->score_over, agc->score_under);

                        if (agc->score_over > agc->change_factor) {
                                agc->vol--;
                                switch_normalize_volume_granular(agc->vol);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] VOL DOWN %d\n", agc->token, agc->vol);
                                //agc->score_over = 0;
                        } else if (agc->score_under > agc->change_factor) {
                                agc->vol++;
                                switch_normalize_volume_granular(agc->vol);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "[%s] VOL UP %d\n", agc->token, agc->vol);
                                //agc->score_under = 0;
                        }

                }

        }

        return SWITCH_STATUS_SUCCESS;
}

switch_agc_set()

void switch_agc_set	(	switch_agc_t *	agc,
		uint32_t	energy_avg,
		uint32_t	low_energy_point,
		uint32_t	margin,
		uint32_t	change_factor,
		uint32_t	period_len
	)

Definition at line 453 of file switch_resample.c.

References switch_agc_s::change_factor, switch_agc_s::energy_avg, switch_agc_s::low_energy_point, switch_agc_s::margin, switch_agc_s::period_len, switch_agc_s::score, switch_agc_s::score_avg, switch_agc_s::score_count, switch_agc_s::score_over, switch_agc_s::score_sum, and switch_agc_s::score_under.

Referenced by switch_agc_create().

{
        agc->energy_avg = energy_avg;
        agc->margin = margin;
        agc->change_factor = change_factor;
        agc->period_len = period_len;
        agc->low_energy_point = low_energy_point;

        agc->score = 0;
        agc->score_count = 0;
        agc->score_sum = 0;
        agc->score_avg = 0;
        agc->score_over = 0;
        agc->score_under = 0;
}

switch_agc_set_energy_avg()

void switch_agc_set_energy_avg	(	switch_agc_t *	agc,
		uint32_t	energy_avg
	)

Definition at line 510 of file switch_resample.c.

References switch_agc_s::energy_avg, and switch_assert.

{
        switch_assert(agc);

        agc->energy_avg = energy_avg;
}

switch_agc_set_energy_low()

void switch_agc_set_energy_low	(	switch_agc_t *	agc,
		uint32_t	low_energy_point
	)

Definition at line 517 of file switch_resample.c.

References switch_agc_s::low_energy_point, and switch_assert.

{
        switch_assert(agc);

        agc->low_energy_point = low_energy_point;
}

switch_agc_set_token()

void switch_agc_set_token	(	switch_agc_t *	agc,
		const char *	token
	)

Definition at line 524 of file switch_resample.c.

References switch_agc_s::pool, switch_core_strdup, and switch_agc_s::token.

Referenced by switch_agc_create().

{
        agc->token = switch_core_strdup(agc->pool, token);
}

switch_merge_sln()

uint32_t switch_merge_sln	(	int16_t *	data,
		uint32_t	samples,
		int16_t *	other_data,
		uint32_t	other_samples,
		int	channels
	)

Definition at line 231 of file switch_resample.c.

References switch_normalize_to_16bit.

Referenced by eavesdrop_callback().

{
        int i;
        int32_t x, z;

        if (channels == 0) channels = 1;

        if (samples > other_samples) {
                x = other_samples;
        } else {
                x = samples;
        }

        for (i = 0; i < x * channels; i++) {
                z = data[i] + other_data[i];
                switch_normalize_to_16bit(z);
                data[i] = (int16_t) z;
        }

        return x;
}

switch_mux_channels()

void switch_mux_channels	(	int16_t *	data,
		switch_size_t	samples,
		uint32_t	orig_channels,
		uint32_t	channels
	)

Definition at line 274 of file switch_resample.c.

References switch_assert, switch_normalize_to_16bit, and switch_zmalloc.

Referenced by switch_core_file_read(), switch_core_file_write(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_core_speech_read_tts(), switch_ivr_eavesdrop_session(), and teletone_handler().

{
        switch_size_t i = 0;
        uint32_t j = 0;

        switch_assert(channels < 11);

        if (orig_channels > channels) {
                if (channels == 1) {
                        for (i = 0; i < samples; i++) {
                                int32_t z = 0;
                                for (j = 0; j < orig_channels; j++) {
                                        z += (int16_t) data[i * orig_channels + j];
                                }
                                switch_normalize_to_16bit(z);
                                data[i] = (int16_t) z;
                        }
                } else if (channels == 2) {
                        int mark_buf = 0;
                        for (i = 0; i < samples; i++) {
                                int32_t z_left = 0, z_right = 0;
                                for (j = 0; j < orig_channels; j++) {
                                        if (j % 2) {
                                                z_left += (int16_t) data[i * orig_channels + j];
                                        } else {
                                                z_right += (int16_t) data[i * orig_channels + j];
                                        }
                                }
                                /* mark_buf will always be smaller than the size of data in bytes because orig_channels > channels */
                                switch_normalize_to_16bit(z_left);
                                data[mark_buf++] = (int16_t) z_left;
                                switch_normalize_to_16bit(z_right);
                                data[mark_buf++] = (int16_t) z_right;
                        }
                } 
        } else if (orig_channels < channels) {

                /* interesting problem... take a give buffer and double up every sample in the buffer without using any other buffer.....
                   This way beats the other i think bacause there is no malloc but I do have to copy the data twice */
#if 1
                uint32_t k = 0, len = samples * orig_channels;

                for (i = 0; i < len; i++) {
                        data[i+len] = data[i];
                }

                for (i = 0; i < samples; i++) {
                        for (j = 0; j < channels; j++) {
                                data[k++] = data[i + samples];
                        }
                }

#else
                uint32_t k = 0, len = samples * 2 * orig_channels;
                int16_t *orig = NULL;

                switch_zmalloc(orig, len);
                memcpy(orig, data, len);

                for (i = 0; i < samples; i++) {
                        for (j = 0; j < channels; j++) {
                                data[k++] = orig[i];
                        }
                }

                free(orig);
#endif

        }
}

switch_unmerge_sln()

uint32_t switch_unmerge_sln	(	int16_t *	data,
		uint32_t	samples,
		int16_t *	other_data,
		uint32_t	other_samples,
		int	channels
	)

Definition at line 254 of file switch_resample.c.

Referenced by switch_core_session_read_frame().

{
        int i;
        int32_t x;

        if (channels == 0) channels = 1;

        if (samples > other_samples) {
                x = other_samples;
        } else {
                x = samples;
        }

        for (i = 0; i < x * channels; i++) {
                data[i] -= other_data[i];
        }

        return x;
}