Re: Just getting noise

At just a first quick glance, I'm pretty sure that you don't want to be
creating and destroying the speex encoder/decoder with each frame. That's
supposed to stay the same for more-or-less the entire session.

Ken Smith
Cell: 425-443-2359
Email: [email protected]
Blog: http://blog.wouldbetheologian.com/


On Wed, Nov 16, 2011 at 2:52 PM, Christopher Schaefer <[email protected]>wrote:

> 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;
>                }
> _______________________________________________
> Speex-dev mailing list
> [email protected]
> http://lists.xiph.org/mailman/listinfo/speex-dev
>

_______________________________________________
Speex-dev mailing list
[email protected]
http://lists.xiph.org/mailman/listinfo/speex-dev