codec_speex.c

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- An open source telephony toolkit.
00003  *
00004  * Copyright (C) 1999 - 2005, Digium, Inc.
00005  *
00006  * Mark Spencer <markster@digium.com>
00007  *
00008  *
00009  * See http://www.asterisk.org for more information about
00010  * the Asterisk project. Please do not directly contact
00011  * any of the maintainers of this project for assistance;
00012  * the project provides a web site, mailing lists and IRC
00013  * channels for your use.
00014  *
00015  * This program is free software, distributed under the terms of
00016  * the GNU General Public License Version 2. See the LICENSE file
00017  * at the top of the source tree.
00018  */
00019 
00020 /*! \file
00021  *
00022  * \brief Translate between signed linear and Speex (Open Codec)
00023  *
00024  * \note This work was motivated by Jeremy McNamara 
00025  * hacked to be configurable by anthm and bkw 9/28/2004
00026  *
00027  * \ingroup codecs
00028  *
00029  * The Speex library - http://www.speex.org
00030  *
00031  */
00032 
00033 /*** MODULEINFO
00034    <depend>speex</depend>
00035    <depend>speex_preprocess</depend>
00036    <use type="external">speexdsp</use>
00037    <support_level>core</support_level>
00038  ***/
00039 
00040 #include "asterisk.h"
00041 
00042 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 419592 $")
00043 
00044 #include <speex/speex.h>
00045 
00046 /* We require a post 1.1.8 version of Speex to enable preprocessing
00047  * and better type handling
00048  */   
00049 #ifdef _SPEEX_TYPES_H
00050 #include <speex/speex_preprocess.h>
00051 #endif
00052 
00053 #include "asterisk/translate.h"
00054 #include "asterisk/module.h"
00055 #include "asterisk/config.h"
00056 #include "asterisk/utils.h"
00057 
00058 /* codec variables */
00059 static int quality = 3;
00060 static int complexity = 2;
00061 static int enhancement = 0;
00062 static int vad = 0;
00063 static int vbr = 0;
00064 static float vbr_quality = 4;
00065 static int abr = 0;
00066 static int dtx = 0;  /* set to 1 to enable silence detection */
00067 
00068 static int preproc = 0;
00069 static int pp_vad = 0;
00070 static int pp_agc = 0;
00071 static float pp_agc_level = 8000; /* XXX what is this 8000 ? */
00072 static int pp_denoise = 0;
00073 static int pp_dereverb = 0;
00074 static float pp_dereverb_decay = 0.4;
00075 static float pp_dereverb_level = 0.3;
00076 
00077 #define TYPE_SILENCE  0x2
00078 #define TYPE_HIGH  0x0
00079 #define TYPE_LOW   0x1
00080 #define TYPE_MASK  0x3
00081 
00082 #define  BUFFER_SAMPLES 8000
00083 #define  SPEEX_SAMPLES  160
00084 
00085 /* Sample frame data */
00086 #include "asterisk/slin.h"
00087 #include "ex_speex.h"
00088 
00089 struct speex_coder_pvt {
00090    void *speex;
00091    SpeexBits bits;
00092    int framesize;
00093    int silent_state;
00094 #ifdef _SPEEX_TYPES_H
00095    SpeexPreprocessState *pp;
00096    spx_int16_t buf[BUFFER_SAMPLES];
00097 #else
00098    int16_t buf[BUFFER_SAMPLES];  /* input, waiting to be compressed */
00099 #endif
00100 };
00101 
00102 static int speex_encoder_construct(struct ast_trans_pvt *pvt, const SpeexMode *profile, int sampling_rate)
00103 {
00104    struct speex_coder_pvt *tmp = pvt->pvt;
00105 
00106    if (!(tmp->speex = speex_encoder_init(profile)))
00107       return -1;
00108 
00109    speex_bits_init(&tmp->bits);
00110    speex_bits_reset(&tmp->bits);
00111    speex_encoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
00112    speex_encoder_ctl(tmp->speex, SPEEX_SET_COMPLEXITY, &complexity);
00113 #ifdef _SPEEX_TYPES_H
00114    if (preproc) {
00115       tmp->pp = speex_preprocess_state_init(tmp->framesize, sampling_rate);
00116       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_VAD, &pp_vad);
00117       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC, &pp_agc);
00118       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &pp_agc_level);
00119       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DENOISE, &pp_denoise);
00120       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB, &pp_dereverb);
00121       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &pp_dereverb_decay);
00122       speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &pp_dereverb_level);
00123    }
00124 #endif
00125    if (!abr && !vbr) {
00126       speex_encoder_ctl(tmp->speex, SPEEX_SET_QUALITY, &quality);
00127       if (vad)
00128          speex_encoder_ctl(tmp->speex, SPEEX_SET_VAD, &vad);
00129    }
00130    if (vbr) {
00131       speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR, &vbr);
00132       speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR_QUALITY, &vbr_quality);
00133    }
00134    if (abr)
00135       speex_encoder_ctl(tmp->speex, SPEEX_SET_ABR, &abr);
00136    if (dtx)
00137       speex_encoder_ctl(tmp->speex, SPEEX_SET_DTX, &dtx); 
00138    tmp->silent_state = 0;
00139 
00140    return 0;
00141 }
00142 
00143 static int lintospeex_new(struct ast_trans_pvt *pvt)
00144 {
00145    return speex_encoder_construct(pvt, &speex_nb_mode, 8000);
00146 }
00147 
00148 static int lin16tospeexwb_new(struct ast_trans_pvt *pvt)
00149 {
00150    return speex_encoder_construct(pvt, &speex_wb_mode, 16000);
00151 }
00152 
00153 static int lin32tospeexuwb_new(struct ast_trans_pvt *pvt)
00154 {
00155    return speex_encoder_construct(pvt, &speex_uwb_mode, 32000);
00156 }
00157 
00158 static int speex_decoder_construct(struct ast_trans_pvt *pvt, const SpeexMode *profile)
00159 {
00160    struct speex_coder_pvt *tmp = pvt->pvt;
00161    
00162    if (!(tmp->speex = speex_decoder_init(profile)))
00163       return -1;
00164 
00165    speex_bits_init(&tmp->bits);
00166    speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
00167    if (enhancement)
00168       speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);
00169 
00170    return 0;
00171 }
00172 
00173 static int speextolin_new(struct ast_trans_pvt *pvt)
00174 {
00175    return speex_decoder_construct(pvt, &speex_nb_mode);
00176 }
00177 
00178 static int speexwbtolin16_new(struct ast_trans_pvt *pvt)
00179 {
00180    return speex_decoder_construct(pvt, &speex_wb_mode);
00181 }
00182 
00183 static int speexuwbtolin32_new(struct ast_trans_pvt *pvt)
00184 {
00185    return speex_decoder_construct(pvt, &speex_uwb_mode);
00186 }
00187 
00188 /*! \brief convert and store into outbuf */
00189 static int speextolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
00190 {
00191    struct speex_coder_pvt *tmp = pvt->pvt;
00192 
00193    /* Assuming there's space left, decode into the current buffer at
00194       the tail location.  Read in as many frames as there are */
00195    int x;
00196    int res;
00197    int16_t *dst = pvt->outbuf.i16;
00198    /* XXX fout is a temporary buffer, may have different types */
00199 #ifdef _SPEEX_TYPES_H
00200    spx_int16_t fout[1024];
00201 #else
00202    float fout[1024];
00203 #endif
00204 
00205    if (f->datalen == 0) {  /* Native PLC interpolation */
00206       if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
00207          ast_log(LOG_WARNING, "Out of buffer space\n");
00208          return -1;
00209       }
00210 #ifdef _SPEEX_TYPES_H
00211       speex_decode_int(tmp->speex, NULL, dst + pvt->samples);
00212 #else
00213       speex_decode(tmp->speex, NULL, fout);
00214       for (x=0;x<tmp->framesize;x++) {
00215          dst[pvt->samples + x] = (int16_t)fout[x];
00216       }
00217 #endif
00218       pvt->samples += tmp->framesize;
00219       pvt->datalen += 2 * tmp->framesize; /* 2 bytes/sample */
00220       return 0;
00221    }
00222 
00223    /* Read in bits */
00224    speex_bits_read_from(&tmp->bits, f->data.ptr, f->datalen);
00225    for (;;) {
00226 #ifdef _SPEEX_TYPES_H
00227       res = speex_decode_int(tmp->speex, &tmp->bits, fout);
00228 #else
00229       res = speex_decode(tmp->speex, &tmp->bits, fout);
00230 #endif
00231       if (res < 0)
00232          break;
00233       if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
00234          ast_log(LOG_WARNING, "Out of buffer space\n");
00235          return -1;
00236       }
00237       for (x = 0 ; x < tmp->framesize; x++)
00238          dst[pvt->samples + x] = (int16_t)fout[x];
00239       pvt->samples += tmp->framesize;
00240       pvt->datalen += 2 * tmp->framesize; /* 2 bytes/sample */
00241    }
00242    return 0;
00243 }
00244 
00245 /*! \brief store input frame in work buffer */
00246 static int lintospeex_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
00247 {
00248    struct speex_coder_pvt *tmp = pvt->pvt;
00249 
00250    /* XXX We should look at how old the rest of our stream is, and if it
00251       is too old, then we should overwrite it entirely, otherwise we can
00252       get artifacts of earlier talk that do not belong */
00253    memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
00254    pvt->samples += f->samples;
00255    return 0;
00256 }
00257 
00258 /*! \brief convert work buffer and produce output frame */
00259 static struct ast_frame *lintospeex_frameout(struct ast_trans_pvt *pvt)
00260 {
00261    struct speex_coder_pvt *tmp = pvt->pvt;
00262    int is_speech=1;
00263    int datalen = 0;  /* output bytes */
00264    int samples = 0;  /* output samples */
00265 
00266    /* We can't work on anything less than a frame in size */
00267    if (pvt->samples < tmp->framesize)
00268       return NULL;
00269    speex_bits_reset(&tmp->bits);
00270    while (pvt->samples >= tmp->framesize) {
00271 #ifdef _SPEEX_TYPES_H
00272       /* Preprocess audio */
00273       if (preproc)
00274          is_speech = speex_preprocess(tmp->pp, tmp->buf + samples, NULL);
00275       /* Encode a frame of data */
00276       if (is_speech) {
00277          /* If DTX enabled speex_encode returns 0 during silence */
00278          is_speech = speex_encode_int(tmp->speex, tmp->buf + samples, &tmp->bits) || !dtx;
00279       } else {
00280          /* 5 zeros interpreted by Speex as silence (submode 0) */
00281          speex_bits_pack(&tmp->bits, 0, 5);
00282       }
00283 #else
00284       {
00285          float fbuf[1024];
00286          int x;
00287          /* Convert to floating point */
00288          for (x = 0; x < tmp->framesize; x++)
00289             fbuf[x] = tmp->buf[samples + x];
00290          /* Encode a frame of data */
00291          is_speech = speex_encode(tmp->speex, fbuf, &tmp->bits) || !dtx;
00292       }
00293 #endif
00294       samples += tmp->framesize;
00295       pvt->samples -= tmp->framesize;
00296    }
00297 
00298    /* Move the data at the end of the buffer to the front */
00299    if (pvt->samples)
00300       memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
00301 
00302    /* Use AST_FRAME_CNG to signify the start of any silence period */
00303    if (is_speech) {
00304       tmp->silent_state = 0;
00305    } else {
00306       if (tmp->silent_state) {
00307          return NULL;
00308       } else {
00309          struct ast_frame frm = {
00310             .frametype = AST_FRAME_CNG,
00311             .src = pvt->t->name,
00312          };
00313 
00314          /*
00315           * XXX I don't think the AST_FRAME_CNG code has ever
00316           * really worked for speex.  There doesn't seem to be
00317           * any consumers of the frame type.  Everyone that
00318           * references the type seems to pass the frame on.
00319           */
00320          tmp->silent_state = 1;
00321 
00322          /* XXX what now ? format etc... */
00323          return ast_frisolate(&frm);
00324       }
00325    }
00326 
00327    /* Terminate bit stream */
00328    speex_bits_pack(&tmp->bits, 15, 5);
00329    datalen = speex_bits_write(&tmp->bits, pvt->outbuf.c, pvt->t->buf_size);
00330    return ast_trans_frameout(pvt, datalen, samples);
00331 }
00332 
00333 static void speextolin_destroy(struct ast_trans_pvt *arg)
00334 {
00335    struct speex_coder_pvt *pvt = arg->pvt;
00336 
00337    speex_decoder_destroy(pvt->speex);
00338    speex_bits_destroy(&pvt->bits);
00339 }
00340 
00341 static void lintospeex_destroy(struct ast_trans_pvt *arg)
00342 {
00343    struct speex_coder_pvt *pvt = arg->pvt;
00344 #ifdef _SPEEX_TYPES_H
00345    if (preproc)
00346       speex_preprocess_state_destroy(pvt->pp);
00347 #endif
00348    speex_encoder_destroy(pvt->speex);
00349    speex_bits_destroy(&pvt->bits);
00350 }
00351 
00352 static struct ast_translator speextolin = {
00353    .name = "speextolin",
00354    .src_codec = {
00355       .name = "speex",
00356       .type = AST_MEDIA_TYPE_AUDIO,
00357       .sample_rate = 8000,
00358    },
00359    .dst_codec = {
00360       .name = "slin",
00361       .type = AST_MEDIA_TYPE_AUDIO,
00362       .sample_rate = 8000,
00363    },
00364    .format = "slin",
00365    .newpvt = speextolin_new,
00366    .framein = speextolin_framein,
00367    .destroy = speextolin_destroy,
00368    .sample = speex_sample,
00369    .desc_size = sizeof(struct speex_coder_pvt),
00370    .buffer_samples = BUFFER_SAMPLES,
00371    .buf_size = BUFFER_SAMPLES * 2,
00372    .native_plc = 1,
00373 };
00374 
00375 static struct ast_translator lintospeex = {
00376    .name = "lintospeex", 
00377    .src_codec = {
00378       .name = "slin",
00379       .type = AST_MEDIA_TYPE_AUDIO,
00380       .sample_rate = 8000,
00381    },
00382    .dst_codec = {
00383       .name = "speex",
00384       .type = AST_MEDIA_TYPE_AUDIO,
00385       .sample_rate = 8000,
00386    },
00387    .format = "speex",
00388    .newpvt = lintospeex_new,
00389    .framein = lintospeex_framein,
00390    .frameout = lintospeex_frameout,
00391    .destroy = lintospeex_destroy,
00392    .sample = slin8_sample,
00393    .desc_size = sizeof(struct speex_coder_pvt),
00394    .buffer_samples = BUFFER_SAMPLES,
00395    .buf_size = BUFFER_SAMPLES * 2, /* XXX maybe a lot less ? */
00396 };
00397 
00398 static struct ast_translator speexwbtolin16 = {
00399    .name = "speexwbtolin16",
00400    .src_codec = {
00401       .name = "speex",
00402       .type = AST_MEDIA_TYPE_AUDIO,
00403       .sample_rate = 16000,
00404    },
00405    .dst_codec = {
00406       .name = "slin",
00407       .type = AST_MEDIA_TYPE_AUDIO,
00408       .sample_rate = 16000,
00409    }, 
00410    .format = "slin16",
00411    .newpvt = speexwbtolin16_new,
00412    .framein = speextolin_framein,
00413    .destroy = speextolin_destroy,
00414    .sample = speex16_sample,
00415    .desc_size = sizeof(struct speex_coder_pvt),
00416    .buffer_samples = BUFFER_SAMPLES,
00417    .buf_size = BUFFER_SAMPLES * 2,
00418    .native_plc = 1,
00419 };
00420 
00421 static struct ast_translator lin16tospeexwb = {
00422    .name = "lin16tospeexwb",
00423    .src_codec = {
00424       .name = "slin",
00425       .type = AST_MEDIA_TYPE_AUDIO,
00426       .sample_rate = 16000,
00427    },
00428    .dst_codec = {
00429       .name = "speex",
00430       .type = AST_MEDIA_TYPE_AUDIO,
00431       .sample_rate = 16000,
00432    },
00433    .format = "speex16",
00434    .newpvt = lin16tospeexwb_new,
00435    .framein = lintospeex_framein,
00436    .frameout = lintospeex_frameout,
00437    .destroy = lintospeex_destroy,
00438    .sample = slin16_sample,
00439    .desc_size = sizeof(struct speex_coder_pvt),
00440    .buffer_samples = BUFFER_SAMPLES,
00441    .buf_size = BUFFER_SAMPLES * 2, /* XXX maybe a lot less ? */
00442 };
00443 
00444 static struct ast_translator speexuwbtolin32 = {
00445    .name = "speexuwbtolin32",
00446    .src_codec = {
00447       .name = "speex",
00448       .type = AST_MEDIA_TYPE_AUDIO,
00449       .sample_rate = 32000,
00450    },
00451    .dst_codec = {
00452       .name = "slin",
00453       .type = AST_MEDIA_TYPE_AUDIO,
00454       .sample_rate = 32000,
00455    },
00456    .format = "slin32",
00457    .newpvt = speexuwbtolin32_new,
00458    .framein = speextolin_framein,
00459    .destroy = speextolin_destroy,
00460    .desc_size = sizeof(struct speex_coder_pvt),
00461    .buffer_samples = BUFFER_SAMPLES,
00462    .buf_size = BUFFER_SAMPLES * 2,
00463    .native_plc = 1,
00464 };
00465 
00466 static struct ast_translator lin32tospeexuwb = {
00467    .name = "lin32tospeexuwb",
00468    .src_codec = {
00469       .name = "slin",
00470       .type = AST_MEDIA_TYPE_AUDIO,
00471       .sample_rate = 32000,
00472    },
00473    .dst_codec = {
00474       .name = "speex",
00475       .type = AST_MEDIA_TYPE_AUDIO,
00476       .sample_rate = 32000,
00477    },
00478    .format = "speex32",
00479    .newpvt = lin32tospeexuwb_new,
00480    .framein = lintospeex_framein,
00481    .frameout = lintospeex_frameout,
00482    .destroy = lintospeex_destroy,
00483    .desc_size = sizeof(struct speex_coder_pvt),
00484    .buffer_samples = BUFFER_SAMPLES,
00485    .buf_size = BUFFER_SAMPLES * 2, /* XXX maybe a lot less ? */
00486 };
00487 
00488 static int parse_config(int reload) 
00489 {
00490    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
00491    struct ast_config *cfg = ast_config_load("codecs.conf", config_flags);
00492    struct ast_variable *var;
00493    int res;
00494    float res_f;
00495 
00496    if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID)
00497       return 0;
00498 
00499    for (var = ast_variable_browse(cfg, "speex"); var; var = var->next) {
00500       if (!strcasecmp(var->name, "quality")) {
00501          res = abs(atoi(var->value));
00502          if (res > -1 && res < 11) {
00503             ast_verb(3, "CODEC SPEEX: Setting Quality to %d\n",res);
00504             quality = res;
00505          } else 
00506             ast_log(LOG_ERROR,"Error Quality must be 0-10\n");
00507       } else if (!strcasecmp(var->name, "complexity")) {
00508          res = abs(atoi(var->value));
00509          if (res > -1 && res < 11) {
00510             ast_verb(3, "CODEC SPEEX: Setting Complexity to %d\n",res);
00511             complexity = res;
00512          } else 
00513             ast_log(LOG_ERROR,"Error! Complexity must be 0-10\n");
00514       } else if (!strcasecmp(var->name, "vbr_quality")) {
00515          if (sscanf(var->value, "%30f", &res_f) == 1 && res_f >= 0 && res_f <= 10) {
00516             ast_verb(3, "CODEC SPEEX: Setting VBR Quality to %f\n",res_f);
00517             vbr_quality = res_f;
00518          } else
00519             ast_log(LOG_ERROR,"Error! VBR Quality must be 0-10\n");
00520       } else if (!strcasecmp(var->name, "abr_quality")) {
00521          ast_log(LOG_ERROR,"Error! ABR Quality setting obsolete, set ABR to desired bitrate\n");
00522       } else if (!strcasecmp(var->name, "enhancement")) {
00523          enhancement = ast_true(var->value) ? 1 : 0;
00524          ast_verb(3, "CODEC SPEEX: Perceptual Enhancement Mode. [%s]\n",enhancement ? "on" : "off");
00525       } else if (!strcasecmp(var->name, "vbr")) {
00526          vbr = ast_true(var->value) ? 1 : 0;
00527          ast_verb(3, "CODEC SPEEX: VBR Mode. [%s]\n",vbr ? "on" : "off");
00528       } else if (!strcasecmp(var->name, "abr")) {
00529          res = abs(atoi(var->value));
00530          if (res >= 0) {
00531                if (res > 0)
00532                ast_verb(3, "CODEC SPEEX: Setting ABR target bitrate to %d\n",res);
00533                else
00534                ast_verb(3, "CODEC SPEEX: Disabling ABR\n");
00535             abr = res;
00536          } else 
00537             ast_log(LOG_ERROR,"Error! ABR target bitrate must be >= 0\n");
00538       } else if (!strcasecmp(var->name, "vad")) {
00539          vad = ast_true(var->value) ? 1 : 0;
00540          ast_verb(3, "CODEC SPEEX: VAD Mode. [%s]\n",vad ? "on" : "off");
00541       } else if (!strcasecmp(var->name, "dtx")) {
00542          dtx = ast_true(var->value) ? 1 : 0;
00543          ast_verb(3, "CODEC SPEEX: DTX Mode. [%s]\n",dtx ? "on" : "off");
00544       } else if (!strcasecmp(var->name, "preprocess")) {
00545          preproc = ast_true(var->value) ? 1 : 0;
00546          ast_verb(3, "CODEC SPEEX: Preprocessing. [%s]\n",preproc ? "on" : "off");
00547       } else if (!strcasecmp(var->name, "pp_vad")) {
00548          pp_vad = ast_true(var->value) ? 1 : 0;
00549          ast_verb(3, "CODEC SPEEX: Preprocessor VAD. [%s]\n",pp_vad ? "on" : "off");
00550       } else if (!strcasecmp(var->name, "pp_agc")) {
00551          pp_agc = ast_true(var->value) ? 1 : 0;
00552          ast_verb(3, "CODEC SPEEX: Preprocessor AGC. [%s]\n",pp_agc ? "on" : "off");
00553       } else if (!strcasecmp(var->name, "pp_agc_level")) {
00554          if (sscanf(var->value, "%30f", &res_f) == 1 && res_f >= 0) {
00555             ast_verb(3, "CODEC SPEEX: Setting preprocessor AGC Level to %f\n",res_f);
00556             pp_agc_level = res_f;
00557          } else
00558             ast_log(LOG_ERROR,"Error! Preprocessor AGC Level must be >= 0\n");
00559       } else if (!strcasecmp(var->name, "pp_denoise")) {
00560          pp_denoise = ast_true(var->value) ? 1 : 0;
00561          ast_verb(3, "CODEC SPEEX: Preprocessor Denoise. [%s]\n",pp_denoise ? "on" : "off");
00562       } else if (!strcasecmp(var->name, "pp_dereverb")) {
00563          pp_dereverb = ast_true(var->value) ? 1 : 0;
00564          ast_verb(3, "CODEC SPEEX: Preprocessor Dereverb. [%s]\n",pp_dereverb ? "on" : "off");
00565       } else if (!strcasecmp(var->name, "pp_dereverb_decay")) {
00566          if (sscanf(var->value, "%30f", &res_f) == 1 && res_f >= 0) {
00567             ast_verb(3, "CODEC SPEEX: Setting preprocessor Dereverb Decay to %f\n",res_f);
00568             pp_dereverb_decay = res_f;
00569          } else
00570             ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Decay must be >= 0\n");
00571       } else if (!strcasecmp(var->name, "pp_dereverb_level")) {
00572          if (sscanf(var->value, "%30f", &res_f) == 1 && res_f >= 0) {
00573             ast_verb(3, "CODEC SPEEX: Setting preprocessor Dereverb Level to %f\n",res_f);
00574             pp_dereverb_level = res_f;
00575          } else
00576             ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Level must be >= 0\n");
00577       }
00578    }
00579    ast_config_destroy(cfg);
00580    return 0;
00581 }
00582 
00583 static int reload(void) 
00584 {
00585    if (parse_config(1))
00586       return AST_MODULE_LOAD_DECLINE;
00587    return AST_MODULE_LOAD_SUCCESS;
00588 }
00589 
00590 static int unload_module(void)
00591 {
00592    int res = 0;
00593 
00594    res |= ast_unregister_translator(&speextolin);
00595    res |= ast_unregister_translator(&lintospeex);
00596    res |= ast_unregister_translator(&speexwbtolin16);
00597    res |= ast_unregister_translator(&lin16tospeexwb);
00598    res |= ast_unregister_translator(&speexuwbtolin32);
00599    res |= ast_unregister_translator(&lin32tospeexuwb);
00600 
00601 
00602    return res;
00603 }
00604 
00605 static int load_module(void)
00606 {
00607    int res = 0;
00608 
00609    if (parse_config(0))
00610       return AST_MODULE_LOAD_DECLINE;
00611 
00612    res |= ast_register_translator(&speextolin);
00613    res |= ast_register_translator(&lintospeex);
00614    res |= ast_register_translator(&speexwbtolin16);
00615    res |= ast_register_translator(&lin16tospeexwb);
00616    res |= ast_register_translator(&speexuwbtolin32);
00617    res |= ast_register_translator(&lin32tospeexuwb);
00618 
00619    if (res) {
00620       unload_module();
00621       return res;
00622    }
00623 
00624    return res;
00625 }
00626 
00627 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Speex Coder/Decoder",
00628       .support_level = AST_MODULE_SUPPORT_CORE,
00629       .load = load_module,
00630       .unload = unload_module,
00631       .reload = reload,
00632           );

Generated on Thu Apr 16 06:27:30 2015 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6