bridge_softmix_binaural.c File Reference

Multi-party software based binaural mixing. More...

#include "include/bridge_softmix_internal.h"

Include dependency graph for bridge_softmix_binaural.c:

Go to the source code of this file.

Macros
#define	CONVOLUTION_SAMPLE_SIZE   960
#define	CONVOLVE_CHANNEL_PREALLOC   3
#define	CONVOLVE_MAX_BUFFER   4096

Functions
void	add_binaural_mixing (struct ast_bridge *bridge, struct softmix_bridge_data *softmix_data, unsigned int softmix_samples, struct softmix_mixing_array *mixing_array, struct softmix_channel *sc, const char *channel_name)
	Processes audio data with the binaural synthesis and adds the result to the mixing array.
void	binaural_mixing (struct ast_bridge *bridge, struct softmix_bridge_data *softmix_data, struct softmix_mixing_array *mixing_array, int16_t *bin_buf, int16_t *ann_buf)
	Mixes all binaural audio data contained in the mixing array.
void	check_binaural_position_change (struct ast_bridge *bridge, struct softmix_bridge_data *softmix_data)
	Checks if a position change in the virtual enviroment is requested by one of the participants.
void	create_binaural_frame (struct ast_bridge_channel *bridge_channel, struct softmix_channel *sc, int16_t *bin_buf, int16_t *ann_buf, unsigned int softmix_datalen, unsigned int softmix_samples, int16_t *buf)
	Creates a frame out of binaural audio data.
int	do_convolve (struct convolve_channel *chan, int16_t *in_samples, unsigned int in_sample_size, unsigned int hrtf_length)
	Binaural convolving of audio data for a channel.
struct convolve_channel_pair *	do_convolve_pair (struct convolve_data *data, unsigned int pos_id, int16_t *in_samples, unsigned int in_sample_size, const char *channel_name)
	Binaural convolving of audio data for a channel pair (left and right channel).
void	free_convolve_channel (struct convolve_channel *cchan)
	Frees all data needed for binaural processing by an audio channel.
void	free_convolve_channel_pair (struct convolve_channel_pair *cchan_pair)
	Frees all data needed for binaural processing by a pair of audio channels (left and right).
void	free_convolve_data (struct convolve_data *data)
	Frees all channels and data needed for binaural audio processing.
float *	get_hrir (unsigned int chan_pos, unsigned int chan_side)
	Provides a head related impulse response for the given position in the virtual enviroment.
int	init_convolve_channel (struct convolve_channel *channel, unsigned int hrtf_len, unsigned int chan_pos, unsigned int chan_side, unsigned int default_sample_size)
	Initializes all data needed for binaural audio processing.
int	init_convolve_channel_pair (struct convolve_channel_pair *cchan_pair, unsigned int hrtf_len, unsigned int chan_pos, unsigned int default_sample_size)
	Initializes all data needed for binaural audio processing of a channel pair (left and right).
int	init_convolve_data (struct convolve_data *data, unsigned int default_sample_size)
	Preinits a specific number of channels (CONVOLVE_CHANNEL_PREALLOC) at the beginning of a conference.
void	random_binaural_pos_change (struct softmix_bridge_data *softmix_data)
	Randomly changes the virtual positions of conference participants.
void	reset_channel_pair (struct convolve_channel_pair *channel_pair, unsigned int default_sample_size)
	Deletes left over signals on a channel that it can be reused.
int	set_binaural_data_join (struct convolve_data *data, unsigned int default_sample_size)
	Joins a channel into a virtual enviroment build with the help of binaural synthesis.
void	set_binaural_data_leave (struct convolve_data *data, unsigned int pos, unsigned int default_sample_size)
	Removes a channel from the binaural conference bridge. Marks the position in the virtual room as unused that it can be reused by the next channel which enters the conference.
void	softmix_process_write_binaural_audio (struct softmix_channel *sc, unsigned int default_sample_size)
	Writes the binaural audio to a channel.

Detailed Description

Multi-party software based binaural mixing.

Author

Frank Haase fra.h.nosp@m.aase.nosp@m.@goog.nosp@m.lema.nosp@m.il.co.nosp@m.m

Dennis Guse denni.nosp@m.s.gu.nosp@m.se@al.nosp@m.umni.nosp@m..tu-b.nosp@m.erli.nosp@m.n.de

Definition in file bridge_softmix_binaural.c.

Macro Definition Documentation

CONVOLUTION_SAMPLE_SIZE

#define CONVOLUTION_SAMPLE_SIZE   960

The default sample size in an binaural environment with a two-channel codec at 48kHz is 960 samples.

Definition at line 43 of file bridge_softmix_binaural.c.

CONVOLVE_CHANNEL_PREALLOC

#define CONVOLVE_CHANNEL_PREALLOC   3

The number of prealloced channels when a bridge will be created.

Definition at line 37 of file bridge_softmix_binaural.c.

CONVOLVE_MAX_BUFFER

#define CONVOLVE_MAX_BUFFER   4096

Max size of the convolve buffer.

Definition at line 39 of file bridge_softmix_binaural.c.

Function Documentation

add_binaural_mixing()

void add_binaural_mixing	(	struct ast_bridge *	bridge,
		struct softmix_bridge_data *	softmix_data,
		unsigned int	softmix_samples,
		struct softmix_mixing_array *	mixing_array,
		struct softmix_channel *	sc,
		const char *	channel_name
	)

Processes audio data with the binaural synthesis and adds the result to the mixing array.

Parameters

bridge	The conference bridge needed to check if binaural processing is active or not.
softmix_data	Contains all data for the softmix bridge and for the binaural processing.
softmix_samples	The sample size.
mixing_array	The array which holds all audio data for mixing.
sc	The channel which contains the audio data to process.
channel_name	The name of the channel

Definition at line 500 of file bridge_softmix_binaural.c.

{
    struct convolve_channel_pair *pair;
 
    pair = NULL;
    /* We only check binaural things if at least one binaural channel joined. */
    if (!(bridge->softmix.binaural_active && softmix_data->convolve.binaural_active
            && (softmix_samples % CONVOLUTION_SAMPLE_SIZE) == 0)) {
        return;
    }
 
    if (!sc->is_announcement) {
        pair = do_convolve_pair(&softmix_data->convolve, sc->binaural_pos,
                mixing_array->buffers[mixing_array->used_entries], softmix_samples, channel_name);
    }
    sc->our_chan_pair = pair;
    mixing_array->chan_pairs[mixing_array->used_entries] = pair;
}

References convolve_data::binaural_active, ast_bridge_softmix::binaural_active, softmix_channel::binaural_pos, softmix_mixing_array::buffers, softmix_mixing_array::chan_pairs, CONVOLUTION_SAMPLE_SIZE, softmix_bridge_data::convolve, do_convolve_pair(), softmix_channel::is_announcement, NULL, softmix_channel::our_chan_pair, ast_bridge::softmix, and softmix_mixing_array::used_entries.

Referenced by softmix_mixing_loop().

binaural_mixing()

void binaural_mixing	(	struct ast_bridge *	bridge,
		struct softmix_bridge_data *	softmix_data,
		struct softmix_mixing_array *	mixing_array,
		int16_t *	bin_buf,
		int16_t *	ann_buf
	)

Mixes all binaural audio data contained in the mixing array.

Parameters

bridge	The conference bridge needed to check if binaural processing is active or not.
softmix_data	Contains all data for the softmix bridge and for the binaural processing.
mixing_array	The array which holds all audio data for mixing.
bin_buf	The buffer that will contain the mixing results.
ann_buf	The buffer that will contain mixed announcements in an interleaved format.

Definition at line 521 of file bridge_softmix_binaural.c.

{
    unsigned int idx;
    unsigned int x;
 
    if (!(bridge->softmix.binaural_active && softmix_data->convolve.binaural_active)) {
        return;
    }
    /* mix it like crazy (binaural channels) */
    memset(bin_buf, 0, MAX_DATALEN);
    memset(ann_buf, 0, MAX_DATALEN);
 
    for (idx = 0; idx < mixing_array->used_entries; idx++) {
        if (mixing_array->chan_pairs[idx] == NULL) {
            for (x = 0; x < softmix_data->default_sample_size; x++) {
                ast_slinear_saturated_add(bin_buf + (x * 2), mixing_array->buffers[idx] + x);
                ast_slinear_saturated_add(bin_buf + (x * 2) + 1, mixing_array->buffers[idx] + x);
                ann_buf[x * 2] = mixing_array->buffers[idx][x];
                ann_buf[(x * 2) + 1] = mixing_array->buffers[idx][x];
            }
        } else {
            for (x = 0; x < softmix_data->default_sample_size; x++) {
                ast_slinear_saturated_add(bin_buf + (x * 2),
                        mixing_array->chan_pairs[idx]->chan_left.out_data + x);
                ast_slinear_saturated_add(bin_buf + (x * 2) + 1,
                        mixing_array->chan_pairs[idx]->chan_right.out_data + x);
            }
        }
    }
}

References ast_slinear_saturated_add(), convolve_data::binaural_active, ast_bridge_softmix::binaural_active, softmix_mixing_array::buffers, convolve_channel_pair::chan_left, softmix_mixing_array::chan_pairs, convolve_channel_pair::chan_right, softmix_bridge_data::convolve, softmix_bridge_data::default_sample_size, MAX_DATALEN, NULL, convolve_channel::out_data, ast_bridge::softmix, and softmix_mixing_array::used_entries.

Referenced by softmix_mixing_loop().

check_binaural_position_change()

void check_binaural_position_change	(	struct ast_bridge *	bridge,
		struct softmix_bridge_data *	softmix_data
	)

Checks if a position change in the virtual enviroment is requested by one of the participants.

Parameters

bridge	The conference bridge.
softmix_data	The data used by the softmix bridge.

Definition at line 467 of file bridge_softmix_binaural.c.

{
    unsigned int pos_change;
    struct ast_bridge_channel *bridge_channel;
 
    /*
     * We only check binaural things if binaural is activated by the config
     * and at least one binaural channel joined.
     */
    if (!(bridge->softmix.binaural_active && softmix_data->convolve.binaural_active)) {
        return;
    }
    /*
     * Before we pull any audio, we must check if any channel requests a
     * change of binaural positions.
     */
    pos_change = 0;
    AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
        if (!bridge_channel->binaural_pos_change) {
            continue;
        }
        ast_bridge_channel_lock_bridge(bridge_channel);
        bridge_channel->binaural_pos_change = 0;
        ast_bridge_unlock(bridge_channel->bridge);
        pos_change = 1;
    }
 
    if (pos_change) {
        random_binaural_pos_change(softmix_data);
    }
}

References ast_bridge_channel_lock_bridge(), ast_bridge_unlock, AST_LIST_TRAVERSE, convolve_data::binaural_active, ast_bridge_softmix::binaural_active, ast_bridge_channel::binaural_pos_change, ast_bridge_channel::bridge, ast_bridge::channels, softmix_bridge_data::convolve, ast_bridge_channel::entry, random_binaural_pos_change(), and ast_bridge::softmix.

Referenced by softmix_mixing_loop().

create_binaural_frame()

void create_binaural_frame	(	struct ast_bridge_channel *	bridge_channel,
		struct softmix_channel *	sc,
		int16_t *	bin_buf,
		int16_t *	ann_buf,
		unsigned int	softmix_datalen,
		unsigned int	softmix_samples,
		int16_t *	buf
	)

Creates a frame out of binaural audio data.

Parameters

bridge_channel	Contains the information if binaural processing is active or not. If active binaural audio data will be copied, if not mono data will be provided in an interleaved format.
sc	The softmix channel holding all informations for the process.
bin_buf	The buffer that contains all mixing results.
ann_buf	The buffer that contains mixed announcements in an interleaved format.
softmix_datalen	The size of the audio data.
softmix_samples	The number of audio samples.
buf	The buffer that contains all mono mixing results, used if binaural processing is inactive.

Definition at line 553 of file bridge_softmix_binaural.c.

{
    unsigned int i;
 
    sc->write_frame.datalen = softmix_datalen * 2;
    sc->write_frame.samples = softmix_samples * 2;
    if (!bridge_channel->binaural_suspended) {
        sc->binaural_suspended = 0;
        if (sc->is_announcement) {
            memcpy(sc->final_buf, ann_buf, softmix_datalen * 2);
        } else {
            memcpy(sc->final_buf, bin_buf, softmix_datalen * 2);
        }
        return;
    }
 
    /*
     * Mark that binaural output is suspended, since we use two channel audio
     * we copy the same signals into both channels.
     */
    sc->binaural_suspended = 1;
    for (i = 0; i < softmix_samples; i++) {
        sc->final_buf[i * 2] = buf[i];
        sc->final_buf[(i * 2) + 1] = buf[i];
    }
}

References softmix_channel::binaural_suspended, ast_bridge_channel::binaural_suspended, buf, ast_frame::datalen, softmix_channel::final_buf, softmix_channel::is_announcement, ast_frame::samples, and softmix_channel::write_frame.

Referenced by softmix_mixing_loop().

do_convolve()

int do_convolve	(	struct convolve_channel *	chan,
		int16_t *	in_samples,
		unsigned int	in_sample_size,
		unsigned int	hrtf_length
	)

Binaural convolving of audio data for a channel.

Parameters

chan	The channel that will contain the binaural audio data as result.
in_samples	The audio data which will be convolved.
in_sample_size	The size of the audio data.
hrtf_length	The length of the head related transfer function used to convolve the audio.

Return values

0	success
-1	failure

Definition at line 86 of file bridge_softmix_binaural.c.

{
#ifdef BINAURAL_RENDERING
    unsigned int i;
 
    if (in_sample_size != CONVOLUTION_SAMPLE_SIZE) {
        return -1;
    }
 
    /* FFT setting real part */
    for (i = 0; i < CONVOLUTION_SAMPLE_SIZE; i++) {
        chan->fftw_in[i] = in_samples[i] * (FLT_MAX / SHRT_MAX);
    }
 
    for (i = CONVOLUTION_SAMPLE_SIZE; i < hrtf_length; i++) {
        chan->fftw_in[i] = 0;
    }
    fftw_execute(chan->fftw_plan);
 
    /* Imaginary multiplication (frequency space). */
    /* First FFTW result has never an imaginary part. */
    chan->fftw_in[0] = chan->fftw_out[0] * chan->hrtf[0];
    for (i = 1; i < (hrtf_length / 2); i++) {
        /* Real part */
        chan->fftw_in[i] = (chan->fftw_out[i] * chan->hrtf[i]) -
                (chan->fftw_out[hrtf_length - i] * chan->hrtf[hrtf_length - i]);
        /* Imaginary part */
        chan->fftw_in[hrtf_length - i] = (chan->fftw_out[i] * chan->hrtf[hrtf_length - i]) +
                (chan->fftw_out[hrtf_length - i] * chan->hrtf[i]);
    }
 
    /* The last (if even) FFTW result has never an imaginary part. */
    if (hrtf_length % 2 == 0) {
        chan->fftw_in[hrtf_length / 2] = chan->fftw_out[hrtf_length / 2] *
                chan->hrtf[hrtf_length / 2];
    }
 
    /* iFFT */
    fftw_execute(chan->fftw_plan_inverse);
    /* Remove signal increase due to iFFT. */
    for (i = 0; i < hrtf_length; i++) {
        chan->fftw_out[i] = chan->fftw_out[i] / (hrtf_length / 2);
    }
 
    /* Save the block for overlap add in the next iteration. */
    for (i = 0; i < in_sample_size; i++) {
        chan->overlap_add[i] += chan->fftw_out[i];
    }
 
    /* Copy real part to the output, ignore the complex part. */
    for (i = 0; i < in_sample_size; i++) {
        chan->out_data[i] = chan->overlap_add[i] * (SHRT_MAX / FLT_MAX);
        chan->overlap_add[i] = chan->fftw_out[i + in_sample_size];
    }
#endif
    return 0;
}

References CONVOLUTION_SAMPLE_SIZE, convolve_channel::fftw_in, convolve_channel::fftw_out, convolve_channel::hrtf, convolve_channel::out_data, and convolve_channel::overlap_add.

Referenced by do_convolve_pair().

do_convolve_pair()

struct convolve_channel_pair * do_convolve_pair	(	struct convolve_data *	data,
		unsigned int	pos_id,
		int16_t *	in_samples,
		unsigned int	in_sample_size,
		const char *	channel_name
	)

Binaural convolving of audio data for a channel pair (left and right channel).

Parameters

data	Contains the left and right audio channel.
pos_id	The position the channel has in the virtual enviroment.
in_samples	The audio data which will be convolved for both channels.
in_sample_size	The size of the audio data.
channel_name	The name of the channel

Return values

The	channel pair with convolved audio on success.
NULL	failure

Definition at line 145 of file bridge_softmix_binaural.c.

{
    struct convolve_channel_pair *chan_pair;
 
    /* If a position has no active member we will not convolve. */
    if (data->pos_ids[pos_id] != 1) {
        ast_log(LOG_ERROR, "Channel %s: Channel pair has no active member! (pos id = %d)\n",
                channel_name, pos_id);
        return NULL;
    }
 
    chan_pair = data->cchan_pair[pos_id];
    if (do_convolve(&chan_pair->chan_left, in_samples, in_sample_size, data->hrtf_length)) {
        ast_log(LOG_ERROR, "Channel %s: Binaural processing failed.", channel_name);
        return NULL;
    }
 
    if (do_convolve(&chan_pair->chan_right, in_samples, in_sample_size, data->hrtf_length)) {
        ast_log(LOG_ERROR, "Channel %s: Binaural processing failed.", channel_name);
        return NULL;
    }
 
    return chan_pair;
}

References ast_log, convolve_data::cchan_pair, convolve_channel_pair::chan_left, convolve_channel_pair::chan_right, do_convolve(), convolve_data::hrtf_length, LOG_ERROR, NULL, and convolve_data::pos_ids.

Referenced by add_binaural_mixing().

free_convolve_channel()

void free_convolve_channel

(

struct convolve_channel *

cchan

)

Frees all data needed for binaural processing by an audio channel.

Parameters

cchan

The channel to clean up.

Definition at line 341 of file bridge_softmix_binaural.c.

{
#ifdef BINAURAL_RENDERING
    fftw_free(cchan->fftw_out);
    fftw_free(cchan->fftw_in);
    fftw_free(cchan->hrtf);
    ast_free(cchan->overlap_add);
    ast_free(cchan->out_data);
    fftw_destroy_plan(cchan->fftw_plan);
    fftw_destroy_plan(cchan->fftw_plan_inverse);
#endif
}

References ast_free, convolve_channel::fftw_in, convolve_channel::fftw_out, convolve_channel::hrtf, convolve_channel::out_data, and convolve_channel::overlap_add.

Referenced by free_convolve_channel_pair(), and init_convolve_channel_pair().

free_convolve_channel_pair()

void free_convolve_channel_pair

(

struct convolve_channel_pair *

cchan_pair

)

Frees all data needed for binaural processing by a pair of audio channels (left and right).

Parameters

cchan_pair

The channel pair to clean up.

Definition at line 354 of file bridge_softmix_binaural.c.

{
    free_convolve_channel(&cchan_pair->chan_left);
    free_convolve_channel(&cchan_pair->chan_right);
}

References convolve_channel_pair::chan_left, convolve_channel_pair::chan_right, and free_convolve_channel().

Referenced by free_convolve_data(), and init_convolve_data().

free_convolve_data()

void free_convolve_data

(

struct convolve_data *

data

)

Frees all channels and data needed for binaural audio processing.

Parameters

data	Contains all channels and data for the cleanup process.

Definition at line 360 of file bridge_softmix_binaural.c.

{
    unsigned int i;
    ast_free(data->pos_ids);
    for (i = 0; i < data->chan_size; i++) {
        free_convolve_channel_pair(data->cchan_pair[i]);
        ast_free(data->cchan_pair[i]);
    }
    ast_free(data->cchan_pair);
}

References ast_free, convolve_data::cchan_pair, convolve_data::chan_size, free_convolve_channel_pair(), and convolve_data::pos_ids.

Referenced by softmix_bridge_destroy().

get_hrir()

float * get_hrir	(	unsigned int	chan_pos,
		unsigned int	chan_side
	)

Provides a head related impulse response for the given position in the virtual enviroment.

Parameters

chan_pos	The position of the channel in the virtual enviroment.
chan_side	0 for the left audio channel, 1 for the right.

Return values

The	hrir for the given position in the virtual room for either the left or right channels.
NULL	on failure.

Definition at line 172 of file bridge_softmix_binaural.c.

{
#ifdef BINAURAL_RENDERING
    if (chan_side == HRIRS_CHANNEL_LEFT) {
        return hrirs_left[ast_binaural_positions[chan_pos]];
    } else if (chan_side == HRIRS_CHANNEL_RIGHT) {
        return hrirs_right[ast_binaural_positions[chan_pos]];
    }
#else
    ast_log(LOG_ERROR, "Requesting data for the binaural conference feature without "
            "it beeing active.\n");
#endif
 
    return NULL;
}

References ast_binaural_positions, ast_log, HRIRS_CHANNEL_LEFT, HRIRS_CHANNEL_RIGHT, hrirs_left, hrirs_right, LOG_ERROR, and NULL.

Referenced by init_convolve_channel().

init_convolve_channel()

int init_convolve_channel	(	struct convolve_channel *	channel,
		unsigned int	hrtf_len,
		unsigned int	chan_pos,
		unsigned int	chan_side,
		unsigned int	default_sample_size
	)

Initializes all data needed for binaural audio processing.

Parameters

channel	The channel used for binaural audio processing.
hrtf_len	The length of the head related impulse response used for binaural processing.
chan_pos	The position of the channel in the virtual enviroment.
chan_side	0 for the left audio channel, 1 for the right.
default_sample_size	The default size of audio samples.

Return values

0	on success
-1	on failure

Definition at line 188 of file bridge_softmix_binaural.c.

{
#ifdef BINAURAL_RENDERING
    unsigned int j;
    float *hrir;
 
    /* Prepare FFTW. */
    channel->fftw_in = (double *) fftw_malloc(sizeof(double) * (hrtf_len + 1));
    if (channel->fftw_in == NULL) {
        return -1;
    }
 
    channel->fftw_out = (double *) fftw_malloc(sizeof(double) * (hrtf_len + 1));
    if (channel->fftw_out == NULL) {
        fftw_free(channel->fftw_in);
        return -1;
    }
 
    memset(channel->fftw_in, 0, sizeof(double) * (hrtf_len + 1));
    memset(channel->fftw_out, 0, sizeof(double) * (hrtf_len + 1));
 
    channel->fftw_plan = fftw_plan_r2r_1d(hrtf_len, channel->fftw_in, channel->fftw_out,
            FFTW_R2HC, FFTW_PATIENT);
    channel->fftw_plan_inverse = fftw_plan_r2r_1d(hrtf_len, channel->fftw_in, channel->fftw_out,
            FFTW_HC2R, FFTW_PATIENT);
    channel->out_data = ast_calloc(CONVOLVE_MAX_BUFFER, sizeof(int16_t));
    if (channel->out_data == NULL) {
        fftw_free(channel->fftw_in);
        fftw_free(channel->fftw_out);
        return -1;
    }
 
    /* Reuse positions if all positions are already used. */
    chan_pos = chan_pos % HRIRS_IMPULSE_SIZE;
 
    /* Get HRTF for the channels spatial position. */
    hrir = get_hrir(chan_pos, chan_side);
    if (hrir == NULL) {
        fftw_free(channel->fftw_in);
        fftw_free(channel->fftw_out);
        ast_free(channel->out_data);
        return -1;
    }
 
    for (j = 0; j < HRIRS_IMPULSE_LEN; j++) {
        channel->fftw_in[j] = hrir[j];
    }
 
    for (j = HRIRS_IMPULSE_LEN; j < hrtf_len; j++) {
        channel->fftw_in[j] = 0;
    }
 
    fftw_execute(channel->fftw_plan);
    channel->hrtf = (double *) fftw_malloc(sizeof(double) * hrtf_len);
    if (channel->hrtf == NULL) {
        fftw_free(channel->fftw_in);
        fftw_free(channel->fftw_out);
        ast_free(channel->out_data);
        return -1;
    }
 
    for (j = 0; j < hrtf_len; j++) {
        channel->hrtf[j] = channel->fftw_out[j];
    }
    channel->overlap_add = ast_calloc(default_sample_size, sizeof(float));
 
    return 0;
#endif
    return -1;
}

References ast_calloc, ast_free, CONVOLVE_MAX_BUFFER, convolve_channel::fftw_in, convolve_channel::fftw_out, get_hrir(), HRIRS_IMPULSE_LEN, HRIRS_IMPULSE_SIZE, convolve_channel::hrtf, NULL, convolve_channel::out_data, and convolve_channel::overlap_add.

Referenced by init_convolve_channel_pair().

init_convolve_channel_pair()

int init_convolve_channel_pair	(	struct convolve_channel_pair *	cchan_pair,
		unsigned int	hrtf_len,
		unsigned int	chan_pos,
		unsigned int	default_sample_size
	)

Initializes all data needed for binaural audio processing of a channel pair (left and right).

Parameters

cchan_pair	The channel pair used for binaural audio processing.
hrtf_len	The length of the head related impulse response used for binaural processing.
chan_pos	The position of the channel in the virtual enviroment.
default_sample_size	The default size of audio samples.

Return values

0	on success
-1	on failure

Definition at line 260 of file bridge_softmix_binaural.c.

{
#ifdef BINAURAL_RENDERING
    unsigned int hrirs_pos = chan_pos * 2;
    int success = 0;
 
    ast_debug(3, "Binaural pos for the new channel pair will be L: %d R: %d (pos id = %d)\n",
            hrirs_pos, hrirs_pos + 1, chan_pos);
    success = init_convolve_channel(&cchan_pair->chan_left, hrtf_len, chan_pos, HRIRS_CHANNEL_LEFT,
            default_sample_size);
    if (success == -1) {
        return success;
    }
 
    success = init_convolve_channel(&cchan_pair->chan_right, hrtf_len, chan_pos,
            HRIRS_CHANNEL_RIGHT, default_sample_size);
    if (success == -1) {
        free_convolve_channel(&cchan_pair->chan_left);
    }
 
    return success;
#else
    ast_log(LOG_ERROR, "Requesting data for the binaural conference feature "
            "without it beeing active.\n");
 
    return -1;
#endif
}

References ast_debug, ast_log, convolve_channel_pair::chan_left, convolve_channel_pair::chan_right, free_convolve_channel(), HRIRS_CHANNEL_LEFT, HRIRS_CHANNEL_RIGHT, init_convolve_channel(), and LOG_ERROR.

Referenced by init_convolve_data(), and set_binaural_data_join().

init_convolve_data()

int init_convolve_data	(	struct convolve_data *	data,
		unsigned int	default_sample_size
	)

Preinits a specific number of channels (CONVOLVE_CHANNEL_PREALLOC) at the beginning of a conference.

Parameters

data	Contains all channels and data needed for binaural processing (e.g. head related transfer functions).
default_sample_size	The default size of audio samples.

Return values

0	on success
-1	on failure

Definition at line 290 of file bridge_softmix_binaural.c.

{
    unsigned int i;
    unsigned int j;
    int success;
    success = 0;
 
    data->pos_ids = ast_calloc(sizeof(int), sizeof(int) * CONVOLVE_CHANNEL_PREALLOC);
    if (data->pos_ids == NULL) {
        return -1;
    }
    data->chan_size = CONVOLVE_CHANNEL_PREALLOC;
    data->number_channels = 0;
    data->cchan_pair = ast_malloc(sizeof(struct convolve_channel_pair *) *
            CONVOLVE_CHANNEL_PREALLOC);
    if (data->cchan_pair == NULL) {
        ast_free(data->pos_ids);
        return -1;
    }
 
    for (i = 0; i < CONVOLVE_CHANNEL_PREALLOC; i++) {
        data->cchan_pair[i] = ast_malloc(sizeof(struct convolve_channel_pair));
        if (data->cchan_pair[i] == NULL) {
            ast_free(data->pos_ids);
            for (j = 0; j < i; j++) {
                ast_free(data->cchan_pair[j]);
            }
            ast_free(data->cchan_pair);
            return -1;
        }
    }
 
    data->hrtf_length = (default_sample_size * 2) - 1;
    for (i = 0; i < CONVOLVE_CHANNEL_PREALLOC; i++) {
        success = init_convolve_channel_pair(data->cchan_pair[i], data->hrtf_length, i,
                default_sample_size);
        if (success == -1) {
            ast_free(data->pos_ids);
            for (j = 0; j < i; j++) {
                free_convolve_channel_pair(data->cchan_pair[j]);
            }
            for (j = 0; j < CONVOLVE_CHANNEL_PREALLOC; j++) {
                ast_free(data->cchan_pair[j]);
            }
            return -1;
        }
    }
 
    return success;
}

References ast_calloc, ast_free, ast_malloc, convolve_data::cchan_pair, convolve_data::chan_size, CONVOLVE_CHANNEL_PREALLOC, free_convolve_channel_pair(), convolve_data::hrtf_length, init_convolve_channel_pair(), NULL, convolve_data::number_channels, and convolve_data::pos_ids.

Referenced by softmix_mixing_thread().

random_binaural_pos_change()

void random_binaural_pos_change

(

struct softmix_bridge_data *

softmix_data

)

Randomly changes the virtual positions of conference participants.

Parameters

softmix_data

The structure containing all position informations.

Definition at line 61 of file bridge_softmix_binaural.c.

{
    /*
     * We perform a shuffle of all channels, even the ones that aren't used at the
     * moment of shuffling now. This has the efect that new members will be placed
     * randomly too.
     */
    unsigned int i;
    unsigned int j;
    struct convolve_channel_pair *tmp;
 
    if (softmix_data->convolve.chan_size < 2) {
        return;
    }
 
    srand(time(NULL));
    for (i = softmix_data->convolve.chan_size - 1; i > 0; i--) {
        j = rand() % (i + 1);
        tmp = softmix_data->convolve.cchan_pair[i];
        reset_channel_pair(tmp, softmix_data->default_sample_size);
        softmix_data->convolve.cchan_pair[i] = softmix_data->convolve.cchan_pair[j];
        softmix_data->convolve.cchan_pair[j] = tmp;
    }
}

References convolve_data::cchan_pair, convolve_data::chan_size, softmix_bridge_data::convolve, softmix_bridge_data::default_sample_size, NULL, and reset_channel_pair().

Referenced by check_binaural_position_change().

reset_channel_pair()

void reset_channel_pair	(	struct convolve_channel_pair *	channel_pair,
		unsigned int	default_sample_size
	)

Deletes left over signals on a channel that it can be reused.

Parameters

channel_pair	The channel pair which contains the left and right audio channel.
default_sample_size	The sample size which the channel pair uses.

Definition at line 54 of file bridge_softmix_binaural.c.

{
    memset(channel_pair->chan_left.overlap_add, 0, sizeof(float) * default_sample_size);
    memset(channel_pair->chan_right.overlap_add, 0, sizeof(float) * default_sample_size);
}

References convolve_channel_pair::chan_left, convolve_channel_pair::chan_right, and convolve_channel::overlap_add.

Referenced by random_binaural_pos_change(), and set_binaural_data_leave().

set_binaural_data_join()

int set_binaural_data_join	(	struct convolve_data *	data,
		unsigned int	default_sample_size
	)

Joins a channel into a virtual enviroment build with the help of binaural synthesis.

Parameters

data	Contains all channels and data needed for binaural processing (e.g. head related transfer functions).
default_sample_size	The default size of audio samples.

Return values

The	position of the channel in the virtual enviroment.
-1	on failure

Definition at line 371 of file bridge_softmix_binaural.c.

{
    struct convolve_channel_pair **cchan_pair_tmp;
    unsigned int i;
    int *pos_ids_tmp;
 
    /* Raise the number of input channels. */
    data->number_channels++;
    /* We realloc another channel pair if we are out of prealloced ones. */
    /* We have prealloced one at the beginning of a conference and if a member leaves. */
    if (data->chan_size < data->number_channels)  {
        data->chan_size += 1;
 
        pos_ids_tmp = ast_realloc(data->pos_ids, data->chan_size * sizeof(int));
        if (pos_ids_tmp) {
            data->pos_ids = pos_ids_tmp;
        } else {
            goto binaural_join_fails;
        }
 
        data->pos_ids[data->chan_size - 1] = 0;
        cchan_pair_tmp = ast_realloc(data->cchan_pair,
                data->chan_size * sizeof(struct convolve_channel_pair *));
        if (cchan_pair_tmp) {
            data->cchan_pair = cchan_pair_tmp;
        } else {
            goto binaural_join_fails;
        }
 
        data->cchan_pair[data->chan_size - 1] = ast_malloc(sizeof(struct convolve_channel_pair));
        if (data->cchan_pair[data->chan_size - 1] == NULL) {
            goto binaural_join_fails;
        }
 
        i = init_convolve_channel_pair(data->cchan_pair[data->chan_size - 1], data->hrtf_length,
                data->chan_size - 1, default_sample_size);
        if (i == -1) {
            goto binaural_join_fails;
        }
    }
 
    for (i = 0; i < data->chan_size; i++) {
        if (data->pos_ids[i] == 0) {
            data->pos_ids[i] = 1;
            break;
        }
    }
 
    return i;
 
binaural_join_fails:
    data->number_channels--;
    data->chan_size -= 1;
 
    return -1;
}

References ast_malloc, ast_realloc, convolve_data::cchan_pair, convolve_data::chan_size, convolve_data::hrtf_length, init_convolve_channel_pair(), NULL, convolve_data::number_channels, and convolve_data::pos_ids.

Referenced by softmix_bridge_join().

set_binaural_data_leave()

void set_binaural_data_leave	(	struct convolve_data *	data,
		unsigned int	pos,
		unsigned int	default_sample_size
	)

Removes a channel from the binaural conference bridge. Marks the position in the virtual room as unused that it can be reused by the next channel which enters the conference.

Parameters

data	Contains all channels and data needed for binaural processing (e.g. head related transfer functions).
pos	The position of the channel in the virtual enviroment.
default_sample_size	The default size of audio samples.

Definition at line 428 of file bridge_softmix_binaural.c.

{
    if (pos >= data->chan_size || data->pos_ids[pos] == 0) {
        return;
    }
 
    reset_channel_pair(data->cchan_pair[pos], default_sample_size);
    data->number_channels--;
    data->pos_ids[pos] = 0;
}

References convolve_data::cchan_pair, convolve_data::chan_size, convolve_data::number_channels, convolve_data::pos_ids, and reset_channel_pair().

Referenced by softmix_bridge_leave().

softmix_process_write_binaural_audio()

void softmix_process_write_binaural_audio	(	struct softmix_channel *	sc,
		unsigned int	default_sample_size
	)

Writes the binaural audio to a channel.

Parameters

sc	The softmix channel.
default_sample_size	The default size of audio samples.

Definition at line 440 of file bridge_softmix_binaural.c.

{
    unsigned int i;
 
    if (sc->write_frame.samples % default_sample_size != 0) {
        return;
    }
 
    /* If binaural is suspended, the source audio (mono) will be removed. */
    if (sc->binaural_suspended) {
        for (i = 0; i < default_sample_size; i++) {
            ast_slinear_saturated_subtract(&sc->final_buf[i * 2], &sc->our_buf[i]);
            ast_slinear_saturated_subtract(&sc->final_buf[(i * 2) + 1], &sc->our_buf[i]);
        }
        return;
    }
 
  /* If binaural is NOT suspended, the source audio (binaural) will be removed. */
    for (i = 0; i < default_sample_size; i++) {
        ast_slinear_saturated_subtract(&sc->final_buf[i * 2],
                &sc->our_chan_pair->chan_left.out_data[i]);
        ast_slinear_saturated_subtract(&sc->final_buf[(i * 2) + 1],
                &sc->our_chan_pair->chan_right.out_data[i]);
    }
}

References ast_slinear_saturated_subtract(), softmix_channel::binaural_suspended, convolve_channel_pair::chan_left, convolve_channel_pair::chan_right, softmix_channel::final_buf, softmix_channel::our_buf, softmix_channel::our_chan_pair, convolve_channel::out_data, ast_frame::samples, and softmix_channel::write_frame.

Referenced by softmix_process_write_audio().