[Speex-dev] Just getting noise
Steve Checkoway
s at pahtak.org
Wed Nov 16 18:55:17 PST 2011
Just to check, you're using a different state that has been properly initialized for each of encoding and decoding, right?
You might have to provide a minimal sample.
On Nov 16, 2011, at 5:54 PM, Christopher Schaefer wrote:
> 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 <s at pahtak.org> 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 <ken at alanta.com> 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: ken at alanta.com
>>>> Blog: http://blog.wouldbetheologian.com/
>>>>
>>>>
>>>> On Wed, Nov 16, 2011 at 2:52 PM, Christopher Schaefer <disks86 at gmail.com>
>>>> 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
>>>>> Speex-dev at xiph.org
>>>>> http://lists.xiph.org/mailman/listinfo/speex-dev
>>>>
>>>>
>>> _______________________________________________
>>> Speex-dev mailing list
>>> Speex-dev at xiph.org
>>> http://lists.xiph.org/mailman/listinfo/speex-dev
>>>
>>
>> --
>> Steve Checkoway
>>
>>
>>
>>
>> _______________________________________________
>> Speex-dev mailing list
>> Speex-dev at xiph.org
>> http://lists.xiph.org/mailman/listinfo/speex-dev
>>
>>
> _______________________________________________
> Speex-dev mailing list
> Speex-dev at xiph.org
> http://lists.xiph.org/mailman/listinfo/speex-dev
>
--
Steve Checkoway
More information about the Speex-dev
mailing list