code.delx.au - pulseaudio/blob - src/modules/echo-cancel/speex.c

   1 /***
   2     This file is part of PulseAudio.
   3
   4     Copyright 2010 Wim Taymans <wim.taymans@gmail.com>
   5
   6     Contributor: Arun Raghavan <arun.raghavan@collabora.co.uk>
   7
   8     PulseAudio is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU Lesser General Public License as published
  10     by the Free Software Foundation; either version 2.1 of the License,
  11     or (at your option) any later version.
  12
  13     PulseAudio is distributed in the hope that it will be useful, but
  14     WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16     General Public License for more details.
  17
  18     You should have received a copy of the GNU Lesser General Public License
  19     along with PulseAudio; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21     USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <pulsecore/core-util.h>
  29 #include <pulsecore/modargs.h>
  30 #include "echo-cancel.h"
  31
  32 /* should be between 10-20 ms */
  33 #define DEFAULT_FRAME_SIZE_MS 20
  34 /* should be between 100-500 ms */
  35 #define DEFAULT_FILTER_SIZE_MS 200
  36 #define DEFAULT_AGC_ENABLED TRUE
  37 #define DEFAULT_DENOISE_ENABLED TRUE
  38 #define DEFAULT_ECHO_SUPPRESS_ENABLED TRUE
  39 #define DEFAULT_ECHO_SUPPRESS_ATTENUATION 0
  40
  41 static const char* const valid_modargs[] = {
  42     "frame_size_ms",
  43     "filter_size_ms",
  44     "agc",
  45     "denoise",
  46     "echo_suppress",
  47     "echo_suppress_attenuation",
  48     "echo_suppress_attenuation_active",
  49     NULL
  50 };
  51
  52 static void pa_speex_ec_fixate_spec(pa_sample_spec *rec_ss, pa_channel_map *rec_map,
  53                                     pa_sample_spec *play_ss, pa_channel_map *play_map,
  54                                     pa_sample_spec *out_ss, pa_channel_map *out_map) {
  55     out_ss->format = PA_SAMPLE_S16NE;
  56
  57     *play_ss = *out_ss;
  58     *play_map = *out_map;
  59     *rec_ss = *out_ss;
  60     *rec_map = *out_map;
  61 }
  62
  63 static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *out_ss, uint32_t nframes, pa_modargs *ma) {
  64     pa_bool_t agc;
  65     pa_bool_t denoise;
  66     pa_bool_t echo_suppress;
  67     int32_t echo_suppress_attenuation;
  68     int32_t echo_suppress_attenuation_active;
  69
  70     agc = DEFAULT_AGC_ENABLED;
  71     if (pa_modargs_get_value_boolean(ma, "agc", &agc) < 0) {
  72         pa_log("Failed to parse agc value");
  73         goto fail;
  74     }
  75
  76     denoise = DEFAULT_DENOISE_ENABLED;
  77     if (pa_modargs_get_value_boolean(ma, "denoise", &denoise) < 0) {
  78         pa_log("Failed to parse denoise value");
  79         goto fail;
  80     }
  81
  82     echo_suppress = DEFAULT_ECHO_SUPPRESS_ENABLED;
  83     if (pa_modargs_get_value_boolean(ma, "echo_suppress", &echo_suppress) < 0) {
  84         pa_log("Failed to parse echo_suppress value");
  85         goto fail;
  86     }
  87
  88     echo_suppress_attenuation = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
  89     if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation", &echo_suppress_attenuation) < 0) {
  90         pa_log("Failed to parse echo_suppress_attenuation value");
  91         goto fail;
  92     }
  93     if (echo_suppress_attenuation > 0) {
  94         pa_log("echo_suppress_attenuation should be a negative dB value");
  95         goto fail;
  96     }
  97
  98     echo_suppress_attenuation_active = DEFAULT_ECHO_SUPPRESS_ATTENUATION;
  99     if (pa_modargs_get_value_s32(ma, "echo_suppress_attenuation_active", &echo_suppress_attenuation_active) < 0) {
 100         pa_log("Failed to parse echo_suppress_attenuation_active value");
 101         goto fail;
 102     }
 103     if (echo_suppress_attenuation_active > 0) {
 104         pa_log("echo_suppress_attenuation_active should be a negative dB value");
 105         goto fail;
 106     }
 107
 108     if (agc || denoise || echo_suppress) {
 109         spx_int32_t tmp;
 110
 111         if (out_ss->channels != 1) {
 112             pa_log("AGC, denoising and echo suppression only work with channels=1");
 113             goto fail;
 114         }
 115
 116         ec->params.priv.speex.pp_state = speex_preprocess_state_init(nframes, out_ss->rate);
 117
 118         tmp = agc;
 119         speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_AGC, &tmp);
 120
 121         tmp = denoise;
 122         speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
 123
 124         if (echo_suppress) {
 125             if (echo_suppress_attenuation)
 126                 speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS,
 127                                      &echo_suppress_attenuation);
 128
 129             if (echo_suppress_attenuation_active) {
 130                 speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE,
 131                                      &echo_suppress_attenuation_active);
 132             }
 133
 134             speex_preprocess_ctl(ec->params.priv.speex.pp_state, SPEEX_PREPROCESS_SET_ECHO_STATE,
 135                                  ec->params.priv.speex.state);
 136         }
 137
 138         pa_log_info("Loaded speex preprocessor with params: agc=%s, denoise=%s, echo_suppress=%s", pa_yes_no(agc),
 139                     pa_yes_no(denoise), pa_yes_no(echo_suppress));
 140     } else
 141         pa_log_info("All preprocessing options are disabled");
 142
 143     return TRUE;
 144
 145 fail:
 146     return FALSE;
 147 }
 148
 149 pa_bool_t pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
 150                            pa_sample_spec *rec_ss, pa_channel_map *rec_map,
 151                            pa_sample_spec *play_ss, pa_channel_map *play_map,
 152                            pa_sample_spec *out_ss, pa_channel_map *out_map,
 153                            uint32_t *nframes, const char *args) {
 154     int rate;
 155     uint32_t frame_size_ms, filter_size_ms;
 156     pa_modargs *ma;
 157
 158     if (!(ma = pa_modargs_new(args, valid_modargs))) {
 159         pa_log("Failed to parse submodule arguments.");
 160         goto fail;
 161     }
 162
 163     filter_size_ms = DEFAULT_FILTER_SIZE_MS;
 164     if (pa_modargs_get_value_u32(ma, "filter_size_ms", &filter_size_ms) < 0 || filter_size_ms < 1 || filter_size_ms > 2000) {
 165         pa_log("Invalid filter_size_ms specification");
 166         goto fail;
 167     }
 168
 169     frame_size_ms = DEFAULT_FRAME_SIZE_MS;
 170     if (pa_modargs_get_value_u32(ma, "frame_size_ms", &frame_size_ms) < 0 || frame_size_ms < 1 || frame_size_ms > 200) {
 171         pa_log("Invalid frame_size_ms specification");
 172         goto fail;
 173     }
 174
 175     pa_speex_ec_fixate_spec(rec_ss, rec_map, play_ss, play_map, out_ss, out_map);
 176
 177     rate = out_ss->rate;
 178     *nframes = pa_echo_canceller_blocksize_power2(rate, frame_size_ms);
 179
 180     pa_log_debug ("Using nframes %d, channels %d, rate %d", *nframes, out_ss->channels, out_ss->rate);
 181     ec->params.priv.speex.state = speex_echo_state_init_mc(*nframes, (rate * filter_size_ms) / 1000, out_ss->channels, out_ss->channels);
 182
 183     if (!ec->params.priv.speex.state)
 184         goto fail;
 185
 186     speex_echo_ctl(ec->params.priv.speex.state, SPEEX_ECHO_SET_SAMPLING_RATE, &rate);
 187
 188     if (!pa_speex_ec_preprocessor_init(ec, out_ss, *nframes, ma))
 189         goto fail;
 190
 191     pa_modargs_free(ma);
 192     return TRUE;
 193
 194 fail:
 195     if (ma)
 196         pa_modargs_free(ma);
 197     if (ec->params.priv.speex.pp_state) {
 198         speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
 199         ec->params.priv.speex.pp_state = NULL;
 200     }
 201     if (ec->params.priv.speex.state) {
 202         speex_echo_state_destroy(ec->params.priv.speex.state);
 203         ec->params.priv.speex.state = NULL;
 204     }
 205     return FALSE;
 206 }
 207
 208 void pa_speex_ec_run(pa_echo_canceller *ec, const uint8_t *rec, const uint8_t *play, uint8_t *out) {
 209     speex_echo_cancellation(ec->params.priv.speex.state, (const spx_int16_t *) rec, (const spx_int16_t *) play,
 210                             (spx_int16_t *) out);
 211
 212     /* preprecessor is run after AEC. This is not a mistake! */
 213     if (ec->params.priv.speex.pp_state)
 214         speex_preprocess_run(ec->params.priv.speex.pp_state, (spx_int16_t *) out);
 215 }
 216
 217 void pa_speex_ec_done(pa_echo_canceller *ec) {
 218     if (ec->params.priv.speex.pp_state) {
 219         speex_preprocess_state_destroy(ec->params.priv.speex.pp_state);
 220         ec->params.priv.speex.pp_state = NULL;
 221     }
 222
 223     if (ec->params.priv.speex.state) {
 224         speex_echo_state_destroy(ec->params.priv.speex.state);
 225         ec->params.priv.speex.state = NULL;
 226     }
 227 }