[Speex-dev] Just getting noise

[Christopher Schaefer]

I'm completely new to speex and I'm having issues adding it to my
application. I can pass raw PCM and that works fine so I know my
transmission code is fine however when I try to encode/decode using
speex I get noise almost like a whining/buzzing sound. I'm sure it's
and issue in my code but I'm not sure where to start looking other
then my gut tells me I'm not sizing or reading the buffer right. Below
are the functions I'm using. The audio data is from OpenAL and is
16000 frequency, 16bits, and the frames being passed to the included
functions are 640 bytes which if my math is right (very well may not
be) that is 20ms.

               virtual Enigma::u8* Encode(Enigma::u8*
inputBuffer,size_t inputSize,
size_t& outputSize)
               {
                       short *in=(short*)inputBuffer;
                       float *input = new float[(inputSize/2)]();
                       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;

                       const SpeexMode* mode;
                       mode = speex_lib_get_mode (SPEEX_MODEID_NB);

                       /*Create a new encoder state in narrowband mode*/
                       state = speex_encoder_init(mode);

                       /*Set the quality to 8 (15 kbps)*/
                       tmp=8;
                       speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);

                       /*Initialization of the structure that holds the bits*/
                       speex_bits_init(&bits);

                       for (i=0;i<(inputSize/2);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);

                       nbBytes = speex_bits_nbytes(&bits);

                       char* cbits = new char[nbBytes]();

                       /*Copy the bits to an array of char that can be written*/
                       nbBytes = speex_bits_write(&bits, cbits, nbBytes);

                       /*Destroy the encoder state*/
                       speex_encoder_destroy(state);
                       /*Destroy the bit-packing struct*/
                       speex_bits_destroy(&bits);

                       outputSize=nbBytes;


                       delete[] input;

                       return (Enigma::u8*)cbits;
               }

               virtual Enigma::u8* Decode(Enigma::u8*
inputBuffer,size_t inputSize,
size_t& outputSize)
               {
                  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;

                       const SpeexMode* mode;
                       mode = speex_lib_get_mode (SPEEX_MODEID_NB);

                  /*Create a new decoder state in narrowband mode*/
                  state = speex_decoder_init(mode);

                  /*Set the perceptual enhancement on*/
                  tmp=1;
                  speex_decoder_ctl(state, SPEEX_SET_ENH, &tmp);


                  /*Initialization of the structure that holds the bits*/
                  speex_bits_init(&bits);

                  speex_bits_read_from(&bits, (char*)inputBuffer, inputSize);

                  outputSize = speex_bits_nbytes(&bits);

                  float *output = new float[(outputSize/2)]();
                  short *out = new short[(outputSize/2)]();

                  /*Decode the data*/
                  speex_decode(state, &bits, output);

                  for (i=0;i<(inputSize/2);i++)
                  {
                                out[i]=output[i];
                  }

                  /*Destroy the decoder state*/
                  speex_decoder_destroy(state);
                  /*Destroy the bit-stream truct*/
                  speex_bits_destroy(&bits);

                  return (Enigma::u8*)out;
               }