Speex 一个开源的声学回声消除器(Acoustic Echo Cancellation)

 http://arcknowledge.com/audio.compression.speex.devel/2005-01/msg00011.html

 

前段时间,搞了一阵声学回声消除,非常郁闷,因为没有成功,但可以说学到一点东西吧,至少理论上懂了一点。
为什么需要声学回声消除呢?在一般的VOIP软件或视频会议系统中,假设我们只有A和B两个人在通话,首先,A的声音传给B,B然后用喇叭放出来,而这时B的MIC呢则会采集到喇叭放出来的声音,然后传回给A,如果这个传输的过程中时延足够大,A就会听到一个和自己刚才说过的话一样的声音,这就是回声,声学回声消除器的作用就是在B端对B采集到的声音进行处理,把采集到声音包含的A的声音去掉再传给A,这样,A就不会听到自己说过的话了。
声学回声消除的原理我就不说了,这在网上有很多文档,网上缺少的是实现,所以,我在这把一个开源的声学回声消除器介绍一下,希望对有些有人用,如果有人知道怎么把这消除器用的基于实时流的VOIP软件中,希望能一起分享一下。
这个声学回声消除器是一个著名的音频编解码器speex中的一部分,1.1.9版本后的回声消除器才起作用,以前版本的都不行,我用的也是这个版本,测试表明,用同一个模拟文件,它有效果比INTEL IPP库4.1版中的声学回声消除器的还要好。
先说编译。首先,从
www.speex.org上下载speex1.1.9的源代码,解压,打开speex/win32/libspeex中的libspeex.dsw,这个工作区里有两个工程,一个是libspeex,另一个是libspeex_dynamic。然后,将libspeex中的mdf.c文件添加到工程libspeex中,编译即可。
以下是我根据文档封装的一个类,里面有一个测试程序: //file name: speexEC.h
#ifndef SPEEX_EC_H
#define SPEEX_EC_H
#include <stdio.h>
#include <stdlib.h>
#include "speex/speex_echo.h"
#include "speex/speex_preprocess.h" 
class CSpeexEC
{
public:
CSpeexEC();
~CSpeexEC();
void Init(int frame_size=160, int filter_length=1280, int sampling_rate=8000); 
void DoAEC(short *mic, short *ref, short *out);

protected:
void Reset();

private:
bool      m_bHasInit;
SpeexEchoState*   m_pState;
    SpeexPreprocessState* m_pPreprocessorState;
int      m_nFrameSize;
int      m_nFilterLen;
int      m_nSampleRate;
float*      m_pfNoise;
};

#endif

//fine name:speexEC.cpp
#include "SpeexEC.h"

CSpeexEC::CSpeexEC()
{
m_bHasInit   = false;
m_pState   = NULL;
m_pPreprocessorState  = NULL;
m_nFrameSize   = 160;
m_nFilterLen   = 160*8;
m_nSampleRate   = 8000;
m_pfNoise   = NULL;
}

CSpeexEC::~CSpeexEC()
{
Reset();
}

void CSpeexEC::Init(int frame_size, int filter_length, int sampling_rate)
{
Reset(); 

if (frame_size<=0 || filter_length<=0 || sampling_rate<=0)
{
  m_nFrameSize  =160;
  m_nFilterLen  = 160*8;
  m_nSampleRate = 8000;
}
else
{
  m_nFrameSize  =frame_size;
  m_nFilterLen  = filter_length;
  m_nSampleRate = sampling_rate;
}

m_pState = speex_echo_state_init(m_nFrameSize, m_nFilterLen);
m_pPreprocessorState = speex_preprocess_state_init(m_nFrameSize, m_nSampleRate);
m_pfNoise = new float[m_nFrameSize+1];
m_bHasInit = true;
}

void CSpeexEC::Reset()
{
if (m_pState != NULL)
{
  speex_echo_state_destroy(m_pState);
  m_pState = NULL;
}
if (m_pPreprocessorState != NULL)
{
  speex_preprocess_state_destroy(m_pPreprocessorState);
  m_pPreprocessorState = NULL;
}
if (m_pfNoise != NULL)
{
  delete []m_pfNoise;
  m_pfNoise = NULL;
}
m_bHasInit = false;
}

void CSpeexEC:DoAEC(short* mic, short* ref, short* out)
{
if (!m_bHasInit)
  return;

speex_echo_cancel(m_pState, mic, ref, out, m_pfNoise);
    speex_preprocess(m_pPreprocessorState, (__int16 *)out, m_pfNoise);
    
}

可以看出,这个回声消除器类很简单,只要初始化一下就可以调用了。但是,要注意的是,传给回声消除器的两个声音信号,必须同步得非常的好,就是说,在B端,接收到A说的话以后,要把这些话音数据传给回声消除器做参考,然后再传给声卡,声卡再放出来,这有一段延时,这时,B再采集,然后传给回声消除器,与那个参考数据比较,从采集到的数据中把频域和参考数据相同的部分消除掉。如果传给消除器的两个信号同步得不好,即两个信号找不到频域相同的部分,就没有办法进行消除了。
测试程序:

#define NN 160
void main()
{
FILE* ref_fd, *mic_fd, *out_fd;
short ref[NN], mic[NN], out[NN];
ref_fd = fopen ("ref.pcm", "rb"); //打开参考文件,即要消除的声音
mic_fd = fopen ("mic.pcm",  "rb");//打开mic采集到的声音文件,包含回声在里面
out_fd = fopen ("echo.pcm", "wb");//消除了回声以后的文件

CSpeexEC ec;
ec.Init();

while (fread(mic, 1, NN*2, mic_fd))
   {
      fread(ref, 1, NN*2, ref_fd);  
      ec.DoAEC(mic, ref, out);
      fwrite(out, 1, NN*2, out_fd);
   }
  
   fclose(ref_fd);
   fclose(mic_fd);
   fclose(out_fd);
}

  以上的程序是用文件来模拟回声和MIC,但在实时流中是大不一样的,在一般的VOIP软件中,接收对方的声音并传到声卡中播放是在一个线程中进行的,而采集本地的声音并传送到对方又是在另一个线程中进行的,而声学回声消除器在对采集到的声音进行回声消除的同时,还需要播放线程中的数据作为参考,而要同步这两个线程中的数据是非常困难的,因为稍稍有些不同步,声学回声消除器中的自适应滤波器就会发散,不但消除不了回声,还会破坏原始采集到的声音,使被破坏的声音难以分辨。我做过好多尝试,始终无法用软件来实现对这两个线程中的数据进行同步,导致实现失败,希望有经验的网友们一起分享一下这方面的经验。



示例代码:


Sample code

This section shows sample code for encoding and decoding speech using the Speex API. The commands can be used to encode and decode a file by calling:  
% sampleenc in_file.sw | sampledec out_file.sw 
where both files are raw (no header) files encoded at 16 bits per sample (in the machine natural endianness).

 

sampleenc.c

sampleenc takes a raw 16 bits/sample file, encodes it and outputs a Speex stream to stdout. Note that the packing used is NOT compatible with that of speexenc/speexdec.

 

#include <speex/speex.h>
#include <stdio.h>
/*The frame size in hardcoded for this sample code but it doesn't have to be*/
#define FRAME_SIZE 160
int main(int argc, char **argv)
{
char *inFile;
FILE *fin;
short in[FRAME_SIZE];
float input[FRAME_SIZE];
char cbits[200];
int nbBytes;
/*Holds the state of the encoder*/
void *state;
/*Holds bits so they can be read and written to by the Speex routines*/
SpeexBits bits;
int i, tmp;
/*Create a new encoder state in narrowband mode*/
state = speex_encoder_init(&speex_nb_mode);
/*Set the quality to 8 (15 kbps)*/
tmp=8;
speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);
inFile = argv[1];
fin = fopen(inFile, "r");
/*Initialization of the structure that holds the bits*/
speex_bits_init(&bits);
while (1)
{
/*Read a 16 bits/sample audio frame*/
fread(in, sizeof(short), FRAME_SIZE, fin);
if (feof(fin))
break;
/*Copy the 16 bits values to float so Speex can work on them*/
for (i=0;i<FRAME_SIZE;i++)
input[i]=in[i];
/*Flush all the bits in the struct so we can encode a new frame*/
speex_bits_reset(&bits);
/*Encode the frame*/
speex_encode(state, input, &bits);
/*Copy the bits to an array of char that can be written*/
nbBytes = speex_bits_write(&bits, cbits, 200);
/*Write the size of the frame first. This is what sampledec expects but
it's likely to be different in your own application*/
fwrite(&nbBytes, sizeof(int), 1, stdout);
/*Write the compressed data*/
fwrite(cbits, 1, nbBytes, stdout);
}
/*Destroy the encoder state*/
speex_encoder_destroy(state);
/*Destroy the bit-packing struct*/
speex_bits_destroy(&bits);
fclose(fin);
return 0;
}

 

sampledec.c

sampledec reads a Speex stream from stdin, decodes it and outputs it to a raw 16 bits/sample file. Note that the packing used is NOT compatible with that of speexenc/speexdec.

 

#include <speex/speex.h>
#include <stdio.h>
/*The frame size in hardcoded for this sample code but it doesn't have to be*/
#define FRAME_SIZE 160
int main(int argc, char **argv)
{
char *outFile;
FILE *fout;
/*Holds the audio that will be written to file (16 bits per sample)*/
short out[FRAME_SIZE];
/*Speex handle samples as float, so we need an array of floats*/
float output[FRAME_SIZE];
char cbits[200];
int nbBytes;
/*Holds the state of the decoder*/
void *state;
/*Holds bits so they can be read and written to by the Speex routines*/
SpeexBits bits;
int i, tmp;
/*Create a new decoder state in narrowband mode*/
state = speex_decoder_init(&speex_nb_mode);
/*Set the perceptual enhancement on*/
tmp=1;
speex_decoder_ctl(state, SPEEX_SET_ENH, &tmp);
outFile = argv[1];
fout = fopen(outFile, "w");
/*Initialization of the structure that holds the bits*/
speex_bits_init(&bits);
while (1)
{
/*Read the size encoded by sampleenc, this part will likely be
different in your application*/
fread(&nbBytes, sizeof(int), 1, stdin);
fprintf (stderr, "nbBytes: %d/n", nbBytes);
if (feof(stdin))
break;
/*Read the "packet" encoded by sampleenc*/
fread(cbits, 1, nbBytes, stdin);
/*Copy the data into the bit-stream struct*/
speex_bits_read_from(&bits, cbits, nbBytes);
/*Decode the data*/
speex_decode(state, &bits, output);
/*Copy from float to short (16 bits) for output*/
for (i=0;i<FRAME_SIZE;i++)
out[i]=output[i];
/*Write the decoded audio to file*/
fwrite(out, sizeof(short), FRAME_SIZE, fout);
}
/*Destroy the decoder state*/
speex_decoder_destroy(state);
/*Destroy the bit-stream truct*/
speex_bits_destroy(&bits);
fclose(fout);
return 0;
}

 

 


 




开源 H323 协议中封装的使用参考代码:


/*
* speexcodec.cxx
*
* Speex codec handler
*
* Open H323 Library
*
* Copyright (c) 2002 Equivalence Pty. Ltd.
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Open H323 Library.
*
* The Initial Developer of the Original Code is Equivalence Pty. Ltd.
*
* Contributor(s): ______________________________________.
*
* $Log: speexcodec.cxx,v $
* Revision 1.20  2002/12/08 22:59:41  rogerh
* Add XiphSpeex codec. Not yet finished.
*
* Revision 1.19  2002/12/06 10:11:54  rogerh
* Back out the Xiph Speex changes on a tempoary basis while the Speex
* spec is being redrafted.
*
* Revision 1.18  2002/12/06 03:27:47  robertj
* Fixed MSVC warnings
*
* Revision 1.17  2002/12/05 12:57:17  rogerh
* Speex now uses the manufacturer ID assigned to Xiph.Org.
* To support existing applications using Speex, applications can use the
* EquivalenceSpeex capabilities.
*
* Revision 1.16  2002/11/25 10:24:50  craigs
* Fixed problem with Speex codec names causing mismatched capabilities
* Reported by Ben Lear
*
* Revision 1.15  2002/11/09 07:08:20  robertj
* Hide speex library from OPenH323 library users.
* Made public the media format names.
* Other cosmetic changes.
*
* Revision 1.14  2002/10/24 05:33:19  robertj
* MSVC compatibility
*
* Revision 1.13  2002/10/22 11:54:32  rogerh
* Fix including of speex.h
*
* Revision 1.12  2002/10/22 11:33:04  rogerh
* Use the local speex.h header file
*
* Revision 1.11  2002/10/09 10:55:21  rogerh
* Update the bit rates to match what the codec now does
*
* Revision 1.10  2002/09/02 21:58:40  rogerh
* Update for Speex 0.8.0
*
* Revision 1.9  2002/08/21 06:49:13  rogerh
* Fix the RTP Payload size too small problem with Speex 0.7.0.
*
* Revision 1.8  2002/08/15 18:34:51  rogerh
* Fix some more bugs
*
* Revision 1.7  2002/08/14 19:06:53  rogerh
* Fix some bugs when using the speex library
*
* Revision 1.6  2002/08/14 04:35:33  craigs
* CHanged Speex names to remove spaces
*
* Revision 1.5  2002/08/14 04:30:14  craigs
* Added bit rates to Speex codecs
*
* Revision 1.4  2002/08/14 04:27:26  craigs
* Fixed name of Speex codecs
*
* Revision 1.3  2002/08/14 04:24:43  craigs
* Fixed ifdef problem
*
* Revision 1.2  2002/08/13 14:25:25  craigs
* Added trailing newlines to avoid Linux warnings
*
* Revision 1.1  2002/08/13 14:14:59  craigs
* Initial version
*
*/

#include <ptlib.h>

#ifdef __GNUC__
#pragma implementation "speexcodec.h"
#endif

#include "speexcodec.h"

#include "h323caps.h"
#include "h245.h"
#include "rtp.h"

extern "C" {
#include "speex/libspeex/speex.h"
};


#define new PNEW

#define XIPH_COUNTRY_CODE       0xB5  // (181) Country code for United States
#define XIPH_T35EXTENSION       0
#define XIPH_MANUFACTURER_CODE  0x0026 // Allocated by Delta Inc

#define EQUIVALENCE_COUNTRY_CODE       9  // Country code for Australia
#define EQUIVALENCE_T35EXTENSION       0
#define EQUIVALENCE_MANUFACTURER_CODE  61 // Allocated by Australian Communications Authority, Oct 2000

#define SAMPLES_PER_FRAME        160

#define SPEEX_BASE_NAME "Speex"

#define SPEEX_NARROW2_H323_NAME    SPEEX_BASE_NAME "Narrow-5.95k{sw}"
#define SPEEX_NARROW3_H323_NAME    SPEEX_BASE_NAME "Narrow-8k{sw}"
#define SPEEX_NARROW4_H323_NAME    SPEEX_BASE_NAME "Narrow-11k{sw}"
#define SPEEX_NARROW5_H323_NAME    SPEEX_BASE_NAME "Narrow-15k{sw}"
#define SPEEX_NARROW6_H323_NAME    SPEEX_BASE_NAME "Narrow-18.2k{sw}"

H323_REGISTER_CAPABILITY(SpeexNarrow2AudioCapability, SPEEX_NARROW2_H323_NAME);
H323_REGISTER_CAPABILITY(SpeexNarrow3AudioCapability, SPEEX_NARROW3_H323_NAME);
H323_REGISTER_CAPABILITY(SpeexNarrow4AudioCapability, SPEEX_NARROW4_H323_NAME);
H323_REGISTER_CAPABILITY(SpeexNarrow5AudioCapability, SPEEX_NARROW5_H323_NAME);
H323_REGISTER_CAPABILITY(SpeexNarrow6AudioCapability, SPEEX_NARROW6_H323_NAME);

#define XIPH_SPEEX_NARROW2_H323_NAME    SPEEX_BASE_NAME "Narrow-5.95k(Xiph){sw}"
#define XIPH_SPEEX_NARROW3_H323_NAME    SPEEX_BASE_NAME "Narrow-8k(Xiph){sw}"
#define XIPH_SPEEX_NARROW4_H323_NAME    SPEEX_BASE_NAME "Narrow-11k(Xiph){sw}"
#define XIPH_SPEEX_NARROW5_H323_NAME    SPEEX_BASE_NAME "Narrow-15k(Xiph){sw}"
#define XIPH_SPEEX_NARROW6_H323_NAME    SPEEX_BASE_NAME "Narrow-18.2k(Xiph){sw}"

H323_REGISTER_CAPABILITY(XiphSpeexNarrow2AudioCapability, XIPH_SPEEX_NARROW2_H323_NAME);
H323_REGISTER_CAPABILITY(XiphSpeexNarrow3AudioCapability, XIPH_SPEEX_NARROW3_H323_NAME);
H323_REGISTER_CAPABILITY(XiphSpeexNarrow4AudioCapability, XIPH_SPEEX_NARROW4_H323_NAME);
H323_REGISTER_CAPABILITY(XiphSpeexNarrow5AudioCapability, XIPH_SPEEX_NARROW5_H323_NAME);
H323_REGISTER_CAPABILITY(XiphSpeexNarrow6AudioCapability, XIPH_SPEEX_NARROW6_H323_NAME);

/////////////////////////////////////////////////////////////////////////

static int Speex_Bits_Per_Second(int mode) {
    void *tmp_coder_state;
    int bitrate;
    tmp_coder_state = speex_encoder_init(&speex_nb_mode);
    speex_encoder_ctl(tmp_coder_state, SPEEX_SET_QUALITY, &mode);
    speex_encoder_ctl(tmp_coder_state, SPEEX_GET_BITRATE, &bitrate);
    speex_encoder_destroy(tmp_coder_state); 
    return bitrate;
}

static int Speex_Bytes_Per_Frame(int mode) {
    int bits_per_frame = Speex_Bits_Per_Second(mode) / 50; // (20ms frame size)
    return ((bits_per_frame+7)/8); // round up
}

OpalMediaFormat const OpalSpeexNarrow_5k95(OPAL_SPEEX_NARROW_5k95,
                                           OpalMediaFormat::DefaultAudioSessionID,
                                           RTP_DataFrame::DynamicBase,
                                           TRUE,  // Needs jitter
                                           Speex_Bits_Per_Second(2),
                                           Speex_Bytes_Per_Frame(2),
                                           SAMPLES_PER_FRAME, // 20 milliseconds
                                           OpalMediaFormat::AudioTimeUnits);

OpalMediaFormat const OpalSpeexNarrow_8k(OPAL_SPEEX_NARROW_8k,
                                         OpalMediaFormat::DefaultAudioSessionID,
                                         RTP_DataFrame::DynamicBase,
                                         TRUE,  // Needs jitter
                                         Speex_Bits_Per_Second(3),
                                         Speex_Bytes_Per_Frame(3),
                                         SAMPLES_PER_FRAME, // 20 milliseconds
                                         OpalMediaFormat::AudioTimeUnits);

OpalMediaFormat const OpalSpeexNarrow_11k(OPAL_SPEEX_NARROW_11k,
                                          OpalMediaFormat::DefaultAudioSessionID,
                                          RTP_DataFrame::DynamicBase,
                                          TRUE,  // Needs jitter
                                          Speex_Bits_Per_Second(4),
                                          Speex_Bytes_Per_Frame(4),
                                          SAMPLES_PER_FRAME, // 20 milliseconds
                                          OpalMediaFormat::AudioTimeUnits);

OpalMediaFormat const OpalSpeexNarrow_15k(OPAL_SPEEX_NARROW_15k,
                                          OpalMediaFormat::DefaultAudioSessionID,
                                          RTP_DataFrame::DynamicBase,
                                          TRUE,  // Needs jitter
                                          Speex_Bits_Per_Second(5),
                                          Speex_Bytes_Per_Frame(5),
                                          SAMPLES_PER_FRAME, // 20 milliseconds
                                          OpalMediaFormat::AudioTimeUnits);

OpalMediaFormat const OpalSpeexNarrow_18k2(OPAL_SPEEX_NARROW_18k2,
                                           OpalMediaFormat::DefaultAudioSessionID,
                                           RTP_DataFrame::DynamicBase,
                                           TRUE,  // Needs jitter
                                           Speex_Bits_Per_Second(6),
                                           Speex_Bytes_Per_Frame(6),
                                           SAMPLES_PER_FRAME, // 20 milliseconds
                                           OpalMediaFormat::AudioTimeUnits);


/////////////////////////////////////////////////////////////////////////

SpeexNonStandardAudioCapability::SpeexNonStandardAudioCapability(int mode)
  : H323NonStandardAudioCapability(1, 1,
                                   EQUIVALENCE_COUNTRY_CODE,
                                   EQUIVALENCE_T35EXTENSION,
                                   EQUIVALENCE_MANUFACTURER_CODE,
                                   NULL, 0, 0, P_MAX_INDEX)
{
  PStringStream s;
  s << "Speex bs" << speex_nb_mode.bitstream_version << " Narrow" << mode;
  PINDEX len = s.GetLength();
  memcpy(nonStandardData.GetPointer(len), (const char *)s, len);
}


/////////////////////////////////////////////////////////////////////////

SpeexNarrow2AudioCapability::SpeexNarrow2AudioCapability()
  : SpeexNonStandardAudioCapability(2) 
{
}


PObject * SpeexNarrow2AudioCapability::Clone() const
{
  return new SpeexNarrow2AudioCapability(*this);
}


PString SpeexNarrow2AudioCapability::GetFormatName() const
{
  return SPEEX_NARROW2_H323_NAME;
}


H323Codec * SpeexNarrow2AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_5k95, 2, direction);
}


/////////////////////////////////////////////////////////////////////////

SpeexNarrow3AudioCapability::SpeexNarrow3AudioCapability()
  : SpeexNonStandardAudioCapability(3) 
{
}


PObject * SpeexNarrow3AudioCapability::Clone() const
{
  return new SpeexNarrow3AudioCapability(*this);
}


PString SpeexNarrow3AudioCapability::GetFormatName() const
{
  return SPEEX_NARROW3_H323_NAME;
}


H323Codec * SpeexNarrow3AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_8k, 3, direction);
}


/////////////////////////////////////////////////////////////////////////

SpeexNarrow4AudioCapability::SpeexNarrow4AudioCapability()
  : SpeexNonStandardAudioCapability(4) 
{
}


PObject * SpeexNarrow4AudioCapability::Clone() const
{
  return new SpeexNarrow4AudioCapability(*this);
}


PString SpeexNarrow4AudioCapability::GetFormatName() const
{
  return SPEEX_NARROW4_H323_NAME;
}


H323Codec * SpeexNarrow4AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_11k, 4, direction);
}


/////////////////////////////////////////////////////////////////////////

SpeexNarrow5AudioCapability::SpeexNarrow5AudioCapability()
  : SpeexNonStandardAudioCapability(5) 
{
}


PObject * SpeexNarrow5AudioCapability::Clone() const
{
  return new SpeexNarrow5AudioCapability(*this);
}


PString SpeexNarrow5AudioCapability::GetFormatName() const
{
  return SPEEX_NARROW5_H323_NAME;
}


H323Codec * SpeexNarrow5AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_15k, 5, direction);
}


/////////////////////////////////////////////////////////////////////////

SpeexNarrow6AudioCapability::SpeexNarrow6AudioCapability()
  : SpeexNonStandardAudioCapability(6) 
{
}


PObject * SpeexNarrow6AudioCapability::Clone() const
{
  return new SpeexNarrow6AudioCapability(*this);
}


PString SpeexNarrow6AudioCapability::GetFormatName() const
{
  return SPEEX_NARROW6_H323_NAME;
}


H323Codec * SpeexNarrow6AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_18k2, 6, direction);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNonStandardAudioCapability::XiphSpeexNonStandardAudioCapability(int mode)
  : H323NonStandardAudioCapability(1, 1,
                                   XIPH_COUNTRY_CODE,
                                   XIPH_T35EXTENSION,
                                   XIPH_MANUFACTURER_CODE,
                                   NULL, 0, 0, P_MAX_INDEX)
{
  // FIXME: To be replaced by an ASN defined block of data
  PStringStream s;
  s << "Speex bs" << speex_nb_mode.bitstream_version << " Narrow" << mode;
  PINDEX len = s.GetLength();
  memcpy(nonStandardData.GetPointer(len), (const char *)s, len);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNarrow2AudioCapability::XiphSpeexNarrow2AudioCapability()
  : XiphSpeexNonStandardAudioCapability(2) 
{
}


PObject * XiphSpeexNarrow2AudioCapability::Clone() const
{
  return new XiphSpeexNarrow2AudioCapability(*this);
}


PString XiphSpeexNarrow2AudioCapability::GetFormatName() const
{
  return XIPH_SPEEX_NARROW2_H323_NAME;
}


H323Codec * XiphSpeexNarrow2AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_5k95, 2, direction);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNarrow3AudioCapability::XiphSpeexNarrow3AudioCapability()
  : XiphSpeexNonStandardAudioCapability(3) 
{
}


PObject * XiphSpeexNarrow3AudioCapability::Clone() const
{
  return new XiphSpeexNarrow3AudioCapability(*this);
}


PString XiphSpeexNarrow3AudioCapability::GetFormatName() const
{
  return XIPH_SPEEX_NARROW3_H323_NAME;
}


H323Codec * XiphSpeexNarrow3AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_8k, 3, direction);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNarrow4AudioCapability::XiphSpeexNarrow4AudioCapability()
  : XiphSpeexNonStandardAudioCapability(4) 
{
}


PObject * XiphSpeexNarrow4AudioCapability::Clone() const
{
  return new XiphSpeexNarrow4AudioCapability(*this);
}


PString XiphSpeexNarrow4AudioCapability::GetFormatName() const
{
  return XIPH_SPEEX_NARROW4_H323_NAME;
}


H323Codec * XiphSpeexNarrow4AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_11k, 4, direction);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNarrow5AudioCapability::XiphSpeexNarrow5AudioCapability()
  : XiphSpeexNonStandardAudioCapability(5) 
{
}


PObject * XiphSpeexNarrow5AudioCapability::Clone() const
{
  return new XiphSpeexNarrow5AudioCapability(*this);
}


PString XiphSpeexNarrow5AudioCapability::GetFormatName() const
{
  return XIPH_SPEEX_NARROW5_H323_NAME;
}


H323Codec * XiphSpeexNarrow5AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_15k, 5, direction);
}


/////////////////////////////////////////////////////////////////////////

XiphSpeexNarrow6AudioCapability::XiphSpeexNarrow6AudioCapability()
  : XiphSpeexNonStandardAudioCapability(6) 
{
}


PObject * XiphSpeexNarrow6AudioCapability::Clone() const
{
  return new XiphSpeexNarrow6AudioCapability(*this);
}


PString XiphSpeexNarrow6AudioCapability::GetFormatName() const
{
  return XIPH_SPEEX_NARROW6_H323_NAME;
}


H323Codec * XiphSpeexNarrow6AudioCapability::CreateCodec(H323Codec::Direction direction) const
{
  return new SpeexCodec(OpalSpeexNarrow_18k2, 6, direction);
}


/////////////////////////////////////////////////////////////////////////////

const float MaxSampleValue   = 32767.0;
const float MinSampleValue   = -32767.0;

SpeexCodec::SpeexCodec(const char * name, int mode, Direction dir)
  : H323FramedAudioCodec(name, dir)
{
  PTRACE(3, "Codec/tSpeex mode " << mode << " " << (dir == Encoder ? "en" : "de")
         << "coder created");

  bits = new SpeexBits;
  speex_bits_init(bits);

  if (direction == Encoder) {
    coder_state = speex_encoder_init(&speex_nb_mode);
    speex_encoder_ctl(coder_state, SPEEX_GET_FRAME_SIZE, &encoder_frame_size);
    speex_encoder_ctl(coder_state, SPEEX_SET_QUALITY,    &mode);
  } else {
    coder_state = speex_decoder_init(&speex_nb_mode);
  }
}

SpeexCodec::~SpeexCodec()
{
  speex_bits_destroy(bits);
  delete bits;

  if (direction == Encoder)
    speex_encoder_destroy(coder_state); 
  else
    speex_decoder_destroy(coder_state); 
}


BOOL SpeexCodec::EncodeFrame(BYTE * buffer, unsigned & length)
{
  // convert PCM to float
  float floatData[SAMPLES_PER_FRAME];
  PINDEX i;
  for (i = 0; i < SAMPLES_PER_FRAME; i++)
    floatData[i] = sampleBuffer[i];

  // encode PCM data in sampleBuffer to buffer
  speex_bits_reset(bits); 
  speex_encode(coder_state, floatData, bits); 

  length = speex_bits_write(bits, (char *)buffer, encoder_frame_size); 

  return TRUE;
}


BOOL SpeexCodec::DecodeFrame(const BYTE * buffer, unsigned length, unsigned &)
{
  float floatData[SAMPLES_PER_FRAME];

  // decode Speex data to floats
  speex_bits_read_from(bits, (char *)buffer, length); 
  speex_decode(coder_state, bits, floatData); 

  // convert float to PCM
  PINDEX i;
  for (i = 0; i < SAMPLES_PER_FRAME; i++) {
    float sample = floatData[i];
    if (sample < MinSampleValue)
      sample = MinSampleValue;
    else if (sample > MaxSampleValue)
      sample = MaxSampleValue;
    sampleBuffer[i] = (short)sample;
  }

  return TRUE;
}



VC++ 中使用 API的 char 单字节压缩代码示例:

Encoding and decoding problem in speex 1.0.4

Subject:Encoding and decoding problem in speex 1.0.4
List-id:speex-dev.xiph.org
Hi,
            I am using the speex 1.0.4 library from Windows.
            I have posted my problem before but didn't get a solution. I am doing an
            VOIP project
            in which i am recording sound and streaming it to the peer. I wanted to
            encode and decode
            wav files that brought me to this site.
            I am recording sound in the following format:-
            m_WaveFormatEx.wFormatTag          = WAVE_FORMAT_PCM;
            m_WaveFormatEx.nChannels           = 1;
            m_WaveFormatEx.wBitsPerSample      = 8;
            m_WaveFormatEx.cbSize              = 0;
            m_WaveFormatEx.nSamplesPerSec      = 8000;
            m_WaveFormatEx.nBlockAlign         = 1;
            m_WaveFormatEx.nAvgBytesPerSec     = 8000;
            The recording is as follows :-
            When the buffer(size = 2000 bytes) gets filled with sound data a
            function with the body shown
            below is called.
            LPWAVEHDR lpHdr = (LPWAVEHDR) lParam;
            if(lpHdr->dwBytesRecorded==0 || lpHdr==NULL)
            return ERROR_SUCCESS;
            ::waveInUnprepareHeader(m_hRecord, lpHdr, sizeof(WAVEHDR));
            Here lpHdr->lpData contains the audio data in a character array.
            Now here I want to use Speex codec for encoding the data so the encoding
            function is
            called (I am thankful to Tay YueWeng for the function).
            char *encode(char *buffer, int &encodeSize)
            {
            char   *encodedBuffer = new char[RECBUFFER/2];            /*
            RECBUFFER = 2000 */
            short   speexShort;
            float  speexFloat[RECBUFFER/2];
            void   *mEncode       = speex_encoder_init(&speex_nb_mode);
            /*Initialization of the structure that holds the bits*/
            speex_bits_init(&mBits);
            // Convert the audio to a short then to a float buffer
            int    halfBufferSize = RECBUFFER/2;
            for (int i = 0; i < halfBufferSize; i++)
            {
            memcpy(&speexShort, &buffer[i*2], sizeof(short));
            speexFloat[i]     = speexShort;
            }
            // Encode the sound data using the float buffer
            speex_bits_reset(&mBits);
            speex_encode(mEncode, speexFloat, &mBits);
            encodeSize            = speex_bits_write(&mBits, encodedBuffer,
            RECBUFFER/2);
            /*Destroy the encoder state*/
            speex_encoder_destroy(mEncode);
            /*Destroy the bit-stream struct*/
            speex_bits_destroy(&mBits);
            // Return the encoded buffer
            return encodedBuffer;
            }
            Here i noticed that though my captured audio data is 2000 bytes the
            compressed form is
            always 38 bytes. In the speexFloat array above i get values in the range
            -32767 to +32767.
            Is it correct. Also after calling the 'speex_encode' function the first
            160 values in the
            input float array i.e. speexFloat is changed (why does it happen?Is
            anything abnormal).
            Further after calling the above function for testing I decode the
            returned encoded data
            immediately by calling the decoding function shown bellow :-
            char *decode (char *buffer, int encodeSize)
            {
            char *decodedBuffer   = new char[RECBUFFER];
            short speexShort;
            float speexFloat[RECBUFFER/2];
            // Decode the sound data into a float buffer
            void  *mDecode        = speex_decoder_init(&speex_nb_mode);
            /*Initialization of the structure that holds the bits*/
            speex_bits_init(&mBits);
            int    halfBufferSize = RECBUFFER/2;
            speex_bits_reset(&mBits);
            speex_bits_read_from(&mBits, buffer, encodeSize);
            speex_decode(mDecode, &mBits, speexFloat);
            // Convert from float to short to char
            for (int i = 0; i < halfBufferSize; i++)
            {
            speexShort = speexFloat[i];
            memcpy(&decodedBuffer[i*2], &speexShort, sizeof(short));
            }
            /*Destroy the decoder state*/
            speex_encoder_destroy(mDecode);
            /*Destroy the bit-stream truct*/
            speex_bits_destroy(&mBits);
            // Return the buffer
            return decodedBuffer;
            }
            After decoding using the above function only the first 160 values in the
            decodedBuffer array is
            changed. i.e i encoded an 2000 byte audio data to get a 38 byte encoded
            audio data. On decoding
            the 38 byte audio data i get an decompressed 160 byte data. I don't
            understand whats going
            wrong. I checked all the messages posted in this newsgroup and did'nt
            find an answer so i am
            posting this code hoping that it gets solved soon.  Thanks in advance.
            


本文引用自:http://www.webpp.cn/read.asp?/246.htm

 

The echo canceller is based on the MDF algorithm described in: J. S. Soo, K. K. Pang Multidelay block frequency adaptive filter, IEEE Trans. Acoust. Speech Signal Process., Vol. ASSP-38, No. 2, February 1990. We use the Alternatively Updated MDF (AUMDF) variant. Robustness to double-talk is achieved using a variable learning rate as described in: Valin, J.-M., On Adjusting the Learning Rate in Frequency Domain Echo Cancellation With Double-Talk. IEEE Transactions on Audio, Speech and Language Processing, Vol. 15, No. 3, pp. 1030-1034, 2007. http://people.xiph.org/~jm/papers/valin_taslp2006.pdf There is no explicit double-talk detection, but a continuous variation in the learning rate based on residual echo, double-talk and background noise. About the fixed-point version: All the signals are represented with 16-bit words. The filter weights are represented with 32-bit words, but only the top 16 bits are used in most cases. The lower 16 bits are completely unreliable (due to the fact that the update is done only on the top bits), but help in the adaptation -- probably by removing a "threshold effect" due to quantization (rounding going to zero) when the gradient is small. Another kludge that seems to work good: when performing the weight update, we only move half the way toward the "goal" this seems to reduce the effect of quantization noise in the update phase. This can be seen as applying a gradient descent on a "soft constraint" instead of having a hard constraint.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值