Re: Just getting noise

I'm only doing one frame using speex_encode_int greatly simplifies my
code I'm not sure why the sample I was working off of was converting
the shorts to floats then calling the other encode/decode methods.
Based off of your suggestions I tried the following but I get the same
result.

		virtual Enigma::u8* Encode(Enigma::u8* inputBuffer,size_t inputSize,
size_t& outputSize)
		{
			speex_bits_reset(&mBits);
			speex_encode_int(mState, (Enigma::s16*)inputBuffer, &mBits);
			speex_bits_insert_terminator(&mBits);
			outputSize = speex_bits_nbytes(&mBits);

			/*Copy the bits to an array of char that can be written*/
			Enigma::u8* cbits = new Enigma::u8[outputSize]();
			speex_bits_write(&mBits, (char*)cbits, outputSize);

			return cbits;
		}

		virtual Enigma::u8* Decode(Enigma::u8* inputBuffer,size_t inputSize,
size_t& outputSize)
		{
			speex_bits_reset(&mBits);
			speex_bits_read_from(&mBits, (char*)inputBuffer, inputSize);

			outputSize = speex_bits_nbytes(&mBits);
			Enigma::u8* cbits = new Enigma::u8[outputSize]();
			speex_decode_int(mState,&mBits,(Enigma::s16*)cbits);
			

			return cbits;
		}

On Wed, Nov 16, 2011 at 6:49 PM, Steve Checkoway <[email protected]> wrote:
> The way I do this is to compute the number of frames (by dividing the size
> of my input by the number of bytes per frame and then calling
> speex_encode_int() that many times. Something like
>
>                speex_bits_reset( &bits );
>                for( n = 0; n < num_frames; ++n )
>                {
>                        speex_encode_int( enc_state, (int16_t*)input_tail,
> &bits );
>                        input_tail += BYTES_PER_FRAME;
>                }
>                speex_bits_insert_terminator( &bits );
>                n = speex_bits_nbytes( &bits ) + RTP_HEADER_SIZE;
>
> Of course, I was sending RTP packets.
>
> On the decoding side, I was using the jitter buffer, but I never managed to
> figure out exactly how that was supposed to work (and messages to the list
> got no replies). I think I ended up only ever encoding a single frame at a
> time as a result.
>
> At any rate, you can work out how many frames are in a SpeexBits (I adapted
> code from the list for that, if it's of any interest).
>
> So to decode, work out how many frames you want and then for each frame,
> call speex_decode_int(). My code looks like
>
>                                while( frames > 0 && (ret =
> speex_decode_int(dec_state, &bits, (int16_t *)((char*)data+length))) == 0 )
>                                {
>                                        length += BYTES_PER_FRAME;
>                                        samples -= SAMPLES_PER_FRAME;
>                                        --frames;
>                                        jitter_buffer_tick( jitter );
>                                        lost_frames = 0;
>                                }
>
> You can ignore the lost_frames. That just gets incremented if there isn't
> data in the jitter buffer and once enough frames have been lost, it starts
> buffering data (and so playing silence).
>
> On Nov 16, 2011, at 15:25 , Christopher Schaefer wrote:
>
>> Alright noted, I changed me code so that the state is created in the
>> constructor and destroyed in the destructor of the object. However I'm
>> still getting the same issue although I'm sure that would have bit me
>> sooner or later.
>> The new code is as follows.
>>
>>                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;
>>                        int i;
>>
>>                        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(&mBits);
>>
>>                        /*Encode the frame*/
>>                        speex_encode(mState, input, &mBits);
>>
>>                        nbBytes = speex_bits_nbytes(&mBits);
>>
>>                        char* cbits = new char[nbBytes]();
>>
>>                        /*Copy the bits to an array of char that can be
>> written*/
>>                        nbBytes = speex_bits_write(&mBits, cbits, nbBytes);
>>
>>                        outputSize=nbBytes;
>>
>>                        delete[] input;
>>
>>                        return (Enigma::u8*)cbits;
>>                }
>>
>>                virtual Enigma::u8* Decode(Enigma::u8* inputBuffer,size_t
>> inputSize,
>> size_t& outputSize)
>>                {
>>                   int nbBytes;
>>                   int i;
>>
>>                   speex_bits_read_from(&mBits, (char*)inputBuffer,
>> inputSize);
>>
>>                   outputSize = speex_bits_nbytes(&mBits);
>>
>>                   float *output = new float[(outputSize/2)]();
>>                   short *out = new short[(outputSize/2)]();
>>
>>                   /*Decode the data*/
>>                   speex_decode(mState, &mBits, output);
>>
>>                   for (i=0;i<(inputSize/2);i++)
>>                   {
>>                                 out[i]=output[i];
>>                   }
>>
>>                   return (Enigma::u8*)out;
>>                }
>>
>> On Wed, Nov 16, 2011 at 5:58 PM, Ken Smith <[email protected]> wrote:
>>>
>>> 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
>>
>
> --
> Steve Checkoway
>
>
>
>
> _______________________________________________
> Speex-dev mailing list
> [email protected]
> http://lists.xiph.org/mailman/listinfo/speex-dev
>
>