mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-07 13:30:03 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pulseaudio/src/modules/echo-cancel/speex.c

229 lines
7.9 KiB
C
Raw Normal View History

echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
/***
This file is part of PulseAudio.
Copyright 2010 Wim Taymans <wim.taymans@gmail.com>
Contributor: Arun Raghavan <arun.raghavan@collabora.co.uk>
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
#include <pulsecore/core-util.h>
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
#include <pulsecore/modargs.h>
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
#include "echo-cancel.h"
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
/* should be between 10-20 ms */
#define DEFAULT_FRAME_SIZE_MS 20
/* should be between 100-500 ms */
#define DEFAULT_FILTER_SIZE_MS 200
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
#define DEFAULT_AGC_ENABLED TRUE
#define DEFAULT_DENOISE_ENABLED TRUE
#define DEFAULT_ECHO_SUPPRESS_ENABLED TRUE
#define DEFAULT_ECHO_SUPPRESS_ATTENUATION 0
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
static const char* const valid_modargs[] = {
"frame_size_ms",
"filter_size_ms",
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
"agc",
"denoise",
"echo_suppress",
"echo_suppress_attenuation",
"echo_suppress_attenuation_active",
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
NULL
};
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
static void pa_speex_ec_fixate_spec(pa_sample_spec *source_ss, pa_channel_map *source_map,
Fix up according to Coding Style Only whitespace changes in here
2011-03-02 12:41:26 +01:00
pa_sample_spec *sink_ss, pa_channel_map *sink_map)
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
{
echo-cancel: Ensure correct handling of endianness The adrian module was using home-brewed endianness conversion instead of the appropriate mactos, and speex assumed a little-endian host. This fixes both of these.
2010-09-23 17:46:00 +05:30
source_ss->format = PA_SAMPLE_S16NE;
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
*sink_ss = *source_ss;
*sink_map = *source_map;
}
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *source_ss, uint32_t blocksize, pa_modargs *ma) {
pa_bool_t agc;
pa_bool_t denoise;
pa_bool_t echo_suppress;
int32_t echo_suppress_attenuation;
int32_t echo_suppress_attenuation_active;
agc = DEFAULT_AGC_ENABLED;
if (pa_modargs_get_value_boolean(ma, "agc", &agc) < 0) {
pa_log("Failed to parse agc value");
goto fail;
}
denoise = DEFAULT_DENOISE_ENABLED;
if (pa_modargs_get_value_boolean(ma, "denoise", &denoise) < 0) {
pa_log("Failed to parse denoise value");
goto fail;
}
echo_suppress = DEFAULT_ECHO_SUPPRESS_ENABLED;
if (pa_modargs_get_value_boolean(ma, "echo_suppress", &echo_suppress) < 0) {
pa_log("Failed to parse echo_suppress value");
goto fail;
}
echo_suppress_attenuation = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation", &echo_suppress_attenuation) < 0) {
pa_log("Failed to parse echo_suppress_attenuation value");
goto fail;
}
if (echo_suppress_attenuation > 0) {
pa_log("echo_suppress_attenuation should be a negative dB value");
goto fail;
}
echo_suppress_attenuation_active = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation_active", &echo_suppress_attenuation_active) < 0) {
pa_log("Failed to parse echo_suppress_attenuation_active value");
goto fail;
}
if (echo_suppress_attenuation_active > 0) {
pa_log("echo_suppress_attenuation_active should be a negative dB value");
goto fail;
}
if (agc || denoise || echo_suppress) {
spx_int32_t tmp;
if (source_ss->channels != 1) {
pa_log("AGC, denoising and echo suppression only work with channels=1");
goto fail;
}
ec->params.priv.speex.pp_state = speex_preprocess_state_init(blocksize / pa_frame_size(source_ss), source_ss->rate);
tmp = agc;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_AGC, &tmp);
tmp = denoise;
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
if (echo_suppress) {
if (echo_suppress_attenuation)
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS,
&echo_suppress_attenuation);
if (echo_suppress_attenuation_active) {
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE,
&echo_suppress_attenuation_active);
}
speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_STATE,
ec->params.priv.speex.state);
}
pa_log_info("Loaded speex preprocessor with params: agc=%s, denoise=%s, echo_suppress=%s", pa_yes_no(agc),
pa_yes_no(denoise), pa_yes_no(echo_suppress));
} else
pa_log_info("All preprocessing options are disabled");
return TRUE;
fail:
return FALSE;
}
echo-cancel: Add SSE optimisation to the adrian module Optimises the core inner-product function, which takes the most CPU. The SSE-optimised bits of the adrian echo canceller only if the CPU that PA is running on actually supports SSE.
2010-09-21 20:42:32 +05:30
pa_bool_t pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
pa_sample_spec *source_ss, pa_channel_map *source_map,
pa_sample_spec *sink_ss, pa_channel_map *sink_map,
echo-cancel: Make blocksize a module-wide parameter Since all algorithms will need to specify a block size (the amount of data to be processed together), we make this a common parameter and have the implementation set it at initialisation time.
2010-09-07 14:55:38 +05:30
uint32_t *blocksize, const char *args)
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
{
int framelen, y, rate;
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
uint32_t frame_size_ms, filter_size_ms;
pa_modargs *ma;
if (!(ma = pa_modargs_new(args, valid_modargs))) {
pa_log("Failed to parse submodule arguments.");
goto fail;
}
filter_size_ms = DEFAULT_FILTER_SIZE_MS;
if (pa_modargs_get_value_u32(ma, "filter_size_ms", &filter_size_ms) < 0 || filter_size_ms < 1 || filter_size_ms > 2000) {
pa_log("Invalid filter_size_ms specification");
goto fail;
}
frame_size_ms = DEFAULT_FRAME_SIZE_MS;
if (pa_modargs_get_value_u32(ma, "frame_size_ms", &frame_size_ms) < 0 || frame_size_ms < 1 || frame_size_ms > 200) {
pa_log("Invalid frame_size_ms specification");
goto fail;
}
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
pa_speex_ec_fixate_spec(source_ss, source_map, sink_ss, sink_map);
rate = source_ss->rate;
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
framelen = (rate * frame_size_ms) / 1000;
/* framelen should be a power of 2, round down to nearest power of two */
y = 1 << ((8 * sizeof (int)) - 2);
while (y > framelen)
y >>= 1;
framelen = y;
echo-cancel: Make blocksize a module-wide parameter Since all algorithms will need to specify a block size (the amount of data to be processed together), we make this a common parameter and have the implementation set it at initialisation time.
2010-09-07 14:55:38 +05:30
*blocksize = framelen * pa_frame_size (source_ss);
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
echo-cancel: Make blocksize a module-wide parameter Since all algorithms will need to specify a block size (the amount of data to be processed together), we make this a common parameter and have the implementation set it at initialisation time.
2010-09-07 14:55:38 +05:30
pa_log_debug ("Using framelen %d, blocksize %u, channels %d, rate %d", framelen, *blocksize, source_ss->channels, source_ss->rate);
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
echo-cancel: Let AEC module determine source/sink spec Since the source and sink specification will need to be determined by the AEC algorithm (can it handle multi-channel audio, does it work with a fixed sample rate, etc.), we negotiate these using inout parameters at initialisation time. There is opportunity to make the sink-handling more elegant. Since the sink data isn't used for playback (just processing), we could pass through the data as-is and resample to the required spec before using in the cancellation algorithm. This isn't too important immediately, but would be nice to have.
2010-09-06 22:23:51 +05:30
ec->params.priv.speex.state = speex_echo_state_init_mc (framelen, (rate * filter_size_ms) / 1000, source_ss->channels, source_ss->channels);
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
if (!ec->params.priv.speex.state)
Fix up according to Coding Style Only whitespace changes in here
2011-03-02 12:41:26 +01:00
goto fail;
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
speex_echo_ctl(ec->params.priv.speex.state, SPEEX_ECHO_SET_SAMPLING_RATE, &rate);
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
if (!pa_speex_ec_preprocessor_init(ec, source_ss, *blocksize, ma))
goto fail;
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
pa_modargs_free(ma);
return TRUE;
fail:
if (ma)
Fix up according to Coding Style Only whitespace changes in here
2011-03-02 12:41:26 +01:00
pa_modargs_free(ma);
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
if (ec->params.priv.speex.state)
speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
echo-cancel: Pass arguments to the specific canceller module This allows us to tweak module parameters for whichever AEC module is chosen.
2010-09-06 21:24:55 +05:30
return FALSE;
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
}
Fix up according to Coding Style Only whitespace changes in here
2011-03-02 12:41:26 +01:00
void pa_speex_ec_run(pa_echo_canceller *ec, const uint8_t *rec, const uint8_t *play, uint8_t *out) {
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
speex_echo_cancellation(ec->params.priv.speex.state, (const spx_int16_t *) rec, (const spx_int16_t *) play,
(spx_int16_t *) out);
/* preprecessor is run after AEC. This is not a mistake! */
if (ec->params.priv.speex.pp_state)
speex_preprocess_run(ec->params.priv.speex.pp_state, (spx_int16_t *) out);
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
}
Fix up according to Coding Style Only whitespace changes in here
2011-03-02 12:41:26 +01:00
void pa_speex_ec_done(pa_echo_canceller *ec) {
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
if (ec->params.priv.speex.pp_state) {
speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
ec->params.priv.speex.pp_state = NULL;
}
if (ec->params.priv.speex.state) {
echo-cancel: Fix a crash is speex cleanup If module initialisation fails, the speex done() function might try to free a value that's not been allocated yet. Adding protection for this condition.
2011-05-28 07:51:35 +05:30
speex_echo_state_destroy(ec->params.priv.speex.state);
echo-cancel: Move speex preprocessing out of the main module I initially included put the Speex preprocessing assuming that we'd want to use the digital gain control and noise suppression from Speex for all echo cancelling implementations. In practice, we're probably going to get entire implementations all processing in one package (WebRTC, custom modules from various vendors, etc.). This moves out this preprocessing and related knobs into the speex implementation, which serves to clean out all implementation-specific details from the module-echo-cancel core.
2011-08-25 17:47:05 +05:30
ec->params.priv.speex.state = NULL;
}
echo-cancel: Split out speex code from the core module This splits out the echo-cancelling core from the PA-specific bits to allow us to plug in other echo-cancellation engines.
2010-09-06 15:51:20 +05:30
}
Reference in a new issue Copy permalink