自学教程：C++ speex_bits_write函数代码示例

//function encodes input buffer, stores in output buffer, return number of compressed bytesint encode(char* in, char* out, int max_bytes){  int nbBytes; //track the size of compressed buffer  speex_bits_reset(&enc_bits);  //Flush the struct's bits and prepare for next frame  speex_encode_int(enc_state, (short*)in, &enc_bits); //encode the input  int num_bytes = speex_bits_write(&enc_bits, out, max_bytes); //copy the encoded bytes to output stream  return num_bytes; //return the length of the compressed buffer}

//*****************************************************************************////! Encode a single frame of speex encoded audio.//!//! /param pui16InBuffer is the buffer that contains the raw PCM audio.//! /param ui32InSize is the number of valid bytes in the /e pui16InBuffer//! buffer.//! /param pui8OutBuffer is a pointer to the buffer to store the encoded audio.//! /param ui32OutSize is the size of the buffer pointed to by the//! /e pui8OutBuffer pointer.//!//! This function will take a buffer of PCM audio and encode it into a frame//! of speex compressed audio.  The /e pui16InBuffer parameter should contain//! a single frame of PCM audio.  The /e pui8OutBuffer will contain the encoded//! audio after returning from this function.//!//! /return This function returns the number of encoded bytes in the//! /e pui8OutBuffer parameter.////*****************************************************************************int32_tSpeexEncode(int16_t *pui16InBuffer, uint32_t ui32InSize,            uint8_t *pui8OutBuffer, uint32_t ui32OutSize){    int32_t i32Bytes;    //    // Reset the bit stream before encoding a new frame.    //    speex_bits_reset(&g_sSpeexEncoder.sBits);    //    // Encode a single frame.    //    speex_encode_int(g_sSpeexEncoder.pvState, pui16InBuffer,                     &g_sSpeexEncoder.sBits);    //    // Read the PCM data from the encoded bit stream.    //    i32Bytes = speex_bits_write(&g_sSpeexEncoder.sBits, (char *)pui8OutBuffer,                                ui32OutSize);    //    // Return the number of bytes in the PCM data.    //    return(i32Bytes);}

bool NetworkSoundRecorder::onProcessSamples(const cpp3ds::Int16 *samples, std::size_t sampleCount){	m_samples.insert(m_samples.end(), samples, samples + sampleCount);	std::vector<char> encodedSamples;	char out[m_frameSize*2];	int size = m_samples.size();	int i = 0;	while (size >= m_frameSize)	{		spx_int16_t* audioFrame = &m_samples[0] + i * m_frameSize;		speex_preprocess_run(m_speexPreprocessState, audioFrame);		speex_bits_reset(&m_speexBits);		speex_encode_int(m_speexState, audioFrame, &m_speexBits);		char bytes = speex_bits_write(&m_speexBits, out, sizeof(out));		encodedSamples.push_back(bytes);		encodedSamples.insert(encodedSamples.end(), out, out + bytes);		i++;		size -= m_frameSize;	}	std::vector<cpp3ds::Int16>(m_samples.end() - size, m_samples.end()).swap(m_samples);	std::cout << "size: " << sampleCount * sizeof(cpp3ds::Int16) << std::endl;	m_context->client.sendVoiceData(m_context->name.toAnsiString(), &encodedSamples[0], encodedSamples.size());	return true;}

//*****************************************************************************////! Encode a single frame of speex encoded audio.//!//! /param pusInBuffer is the buffer that contains the raw PCM audio.//! /param ulInSize is the number of valid bytes in the pusInBuffer buffer.//! /param pucOutBuffer is a pointer to the buffer to store the encoded audio.//! /param ulOutSize is the size of the buffer pointed to by the pucOutBuffer//! pointer.//!//! This function will take a buffer of PCM audio and encode it into a frame//! of speex compressed audio.  The /e pusInBuffer parameter should contain//! a single frame of PCM audio.  The /e pucOutBuffer will contain the encoded//! audio after returning from this function.//!//! /return This function returns the number of encoded bytes in the//! /e pucOutBuffer parameter.////*****************************************************************************intSpeexEncode(short *pusInBuffer, unsigned long ulInSize,            unsigned char *pucOutBuffer, unsigned long ulOutSize){    int iBytes;    //    // Reset the bit stream before encoding a new frame.    //    speex_bits_reset(&g_sSpeexEncoder.sBits);    //    // Encode a single frame.    //    speex_encode_int(g_sSpeexEncoder.State, pusInBuffer,                     &g_sSpeexEncoder.sBits);    //    // Read the PCM data from the encoded bit stream.    //    iBytes = speex_bits_write(&g_sSpeexEncoder.sBits, (char *)pucOutBuffer,                              ulOutSize);    //    // return the number of bytes in the PCM data.    //    return(iBytes);}

tsk_size_t tdav_codec_speex_encode(tmedia_codec_t* self, const void* in_data, tsk_size_t in_size, void** out_data, tsk_size_t* out_max_size){		tdav_codec_speex_t* speex = (tdav_codec_speex_t*)self;	tsk_size_t outsize = 0;		if(!self || !in_data || !in_size || !out_data){		TSK_DEBUG_ERROR("Invalid parameter");		return 0;	}		speex_bits_reset(&speex->encoder.bits);	speex_encode_int(speex->encoder.state, (spx_int16_t*)in_data, &speex->encoder.bits);	if(*out_max_size <speex->encoder.size){		if((*out_data = tsk_realloc(*out_data, speex->encoder.size))){			*out_max_size = speex->encoder.size;		}		else{			*out_max_size = 0;			return 0;		}	}		outsize = speex_bits_write(&speex->encoder.bits, *out_data, speex->encoder.size/2);   return outsize;}

static int speex_encode_frame(AVCodecContext *avctx,                      unsigned char *frame, int buf_size, void *data){    SpeexContext *s = avctx->priv_data;    int bytes_written = 0;        if (avctx->channels == 2)        speex_encode_stereo_int(data, avctx->frame_size, &s->bits);            speex_encode_int(s->st, data, &s->bits);    //speex_bits_insert_terminator(&s->bits);            if (!(avctx->flags2 & CODEC_FLAG2_NO_OUTPUT))    {    	bytes_written = speex_bits_write(&s->bits, frame, buf_size);    }	speex_bits_reset(&s->bits);    if (avctx->debug & FF_DEBUG_BITSTREAM)    {            av_log(avctx, AV_LOG_DEBUG, "Speex: encoded speex frame (%d bytes total, framesize: %d)/n",             bytes_written, avctx->frame_size);    }        return bytes_written;}

int Pcm16_2_Speex( unsigned char* out_buf, unsigned char* in_buf, 		   unsigned int size,		   unsigned int channels, unsigned int rate, long h_codec ){  SpeexState* ss;  short* pcm = (short*) in_buf;  char* buffer = (char*)out_buf;  div_t blocks;      ss = (SpeexState*) h_codec;      if (!ss || channels!=1)    return -1;  blocks = div(size>>1, ss->frame_size);  if (blocks.rem) {    ERROR("Pcm16_2_Speex: not integral number of blocks %d.%d/n", 	  blocks.quot, blocks.rem);    return -1;  }      /* For each chunk of ss->frame_size bytes, encode a single frame */  speex_bits_reset(&ss->encoder.bits);  while (blocks.quot--) {    speex_encode_int(ss->encoder.state, pcm, &ss->encoder.bits);    pcm += ss->frame_size;  }      buffer += speex_bits_write(&ss->encoder.bits, buffer, AUDIO_BUFFER_SIZE);  return buffer - (char*)out_buf;}

JNIEXPORT jint JNICALL Java_com_speex_encode_Speex_encode    (JNIEnv *env, jobject obj, jshortArray lin, jint offset, jbyteArray encoded, jint size) {        jshort buffer[enc_frame_size];        jbyte output_buffer[enc_frame_size];	int nsamples = (size-1)/enc_frame_size + 1;	int i, tot_bytes = 0;	if (!codec_open)		return 0;	speex_bits_reset(&ebits);	for (i = 0; i < nsamples; i++) {		env->GetShortArrayRegion(lin, offset + i*enc_frame_size, enc_frame_size, buffer);		speex_encode_int(enc_state, buffer, &ebits);	}	//env->GetShortArrayRegion(lin, offset, enc_frame_size, buffer);	//speex_encode_int(enc_state, buffer, &ebits);	tot_bytes = speex_bits_write(&ebits, (char *)output_buffer,				     enc_frame_size);	env->SetByteArrayRegion(encoded, 0, tot_bytes,				output_buffer);        return (jint)tot_bytes;}

JNIEXPORT jint JNICALL Java_org_thoughtcrime_redphone_codec_SpeexCodec_encode (JNIEnv *env, jobject obj, jshortArray decArr, jbyteArray encArr, jint rawLen ){  if( !initialized ) {    logv( env, "tried to encode without initializing" );    return -1;  }  //  logv( env, "entered encode %d", rawLen );  //  logv( env, "encoding %d samples", rawLen );  jshort *raw_stream = env->GetShortArrayElements( decArr, NULL );  speex_bits_reset( &enc_bits );  //  logv( env, "bits reset" );  //  speex_preprocess_run( prepState, (spx_int16_t *)raw_stream );  speex_encode_int( enc, (spx_int16_t *)raw_stream, &enc_bits );  //  logv( env, "encode complete" );  env->ReleaseShortArrayElements( decArr, raw_stream, JNI_ABORT );  //  logv( env, "writing up to %d bytes to buffer", enc_frame_size );  int nbytes = speex_bits_write( &enc_bits, enc_buffer, enc_frame_size );  //  logv( env, "wrote %d bytes to buffer", nbytes );  env->SetByteArrayRegion( encArr, 0, nbytes, (jbyte*)enc_buffer );  //  logv( env, "wrote back to java buffer" );  return (jint)nbytes;}

static int encode_speex(int16_t * input_frame, uint8_t nbframes, char * output, int bitrate) {	int i, bytesToWrite, nbBytes;  SpeexBits bits;  void * state;  long long total;  speex_bits_init(&bits);  state = speex_encoder_init(&speex_nb_mode);  speex_encoder_ctl(state, SPEEX_SET_QUALITY, &bitrate);  speex_bits_reset(&bits);    total = 0;  for(i=0;i<5*160;i++) {    total += input_frame[i];  }  total /= (5*160);  if(abs(total) < 10)    return 0;  for(i=0;i<5;i++) {	  speex_encode_int(state, input_frame + (i*160), &bits);  }	bytesToWrite = speex_bits_nbytes(&bits);  nbBytes = speex_bits_write(&bits, output, bytesToWrite);  speex_bits_destroy(&bits);  speex_decoder_destroy(state);	return nbBytes;}

void* SpeexEncoder::encodingThreadMethod(void)	{	Threads::Thread::setCancelState(Threads::Thread::CANCEL_ENABLE);	// Threads::Thread::setCancelType(Threads::Thread::CANCEL_ASYNCHRONOUS);		while(true)		{		try			{			/* Read raw audio data from the recording PCM device: */			size_t numFrames=read(recordingBuffer,speexFrameSize);						/* Check for possible error conditions: */			if(numFrames==speexFrameSize&&speex_encode_int(speexState,recordingBuffer,&speexBits)>=0)				{				/* Write packed bits into the SPEEX packet queue: */				char* speexPacket=speexPacketQueue.getWriteSegment();				speex_bits_write(&speexBits,speexPacket,speexPacketSize);				speexPacketQueue.pushSegment();				speex_bits_reset(&speexBits);				}			}		catch(Sound::ALSAPCMDevice::OverrunError)			{			/* Restart the recording PCM device: */			prepare();			start();			}		}		return 0;	}

int spx_encode_frame(int handle ,short *const pcm_data ,char *speex_data){   // char cbits[200];    float input[FRAME_SIZE];    speex_encode_union_t * speex_encode_u = (speex_encode_union_t *)handle;    /*Flush all the bits in the struct so we can encode a new frame*/    speex_bits_reset(&speex_encode_u->bits);    /*Encode the frame*/   // memcpy(input,pcm_data,FRAME_SIZE*2);    int i;    for (i = 0; i < FRAME_SIZE; i++)          input[i] = pcm_data[i];    speex_encode(speex_encode_u->state, input, &speex_encode_u->bits);    ////write rtp packet header!!!!!RTP HEADER    //memcpy(speex_data ,&speex_encode_u->rtp_header ,RTP_HEADER_SIZE);    ///*Copy the bits to an array of char that can be written*/    //int nbBytes = speex_bits_write(&speex_encode_u->bits, &speex_data[RTP_HEADER_SIZE], 38);    //fwrite(&speex_data[RTP_HEADER_SIZE] ,1 ,38 ,fp_speex_send);	int nbBytes = speex_bits_write(&speex_encode_u->bits, speex_data, 38);	fwrite(speex_data ,1 ,38 ,fp_speex_send);	printf("after speex_encode ,write nbBytes = %d  to file !/n" ,nbBytes);	return 0;}

void AudioInput::flushCheck() {	if (bPreviousVoice && iFrames < g.s.iFramesPerPacket)		return;	int flags = 0;	if (g.iAltSpeak > 0)		flags += MessageSpeex::AltSpeak;	if (g.s.lmLoopMode == Settings::Server)		flags += MessageSpeex::LoopBack;	if (! bPreviousVoice)		flags += MessageSpeex::EndSpeech;	flags += (iFrames - 1) << 4;	int len = speex_bits_nbytes(&sbBits);	QByteArray qba(len + 1, 0);	qba[0] = static_cast<unsigned char>(flags);	speex_bits_write(&sbBits, qba.data() + 1, len);	MessageSpeex msPacket;	msPacket.qbaSpeexPacket = qba;	msPacket.iSeq = iFrameCounter;	if (g.s.lmLoopMode == Settings::Local) {		LoopPlayer::lpLoopy.addFrame(qba, msPacket.iSeq);	} else if (g.sh) {		g.sh->sendMessage(&msPacket);	}	iFrames = 0;	speex_bits_reset(&sbBits);}

int	speex_encoder_encode(unsigned char* src, int inlen, unsigned char*dest, int outlen) {	int len = 0;	speex_bits_reset(&bits);	speex_encode_int(speex_encoder, (short*)src, &bits);	len = speex_bits_write(&bits, dest, outlen);	return len;}

int spx_encode_frame(int handle ,short *pcm_data ,char *speex_data){   // char cbits[200];    float input[FRAME_SIZE];    speex_encode_union_t * speex_encode_u = (speex_encode_union_t *)handle;    /*Flush all the bits in the struct so we can encode a new frame*/    speex_bits_reset(&speex_encode_u->bits);    /*Encode the frame*/   // memcpy(input,pcm_data,FRAME_SIZE*2);    int i;    for (i = 0; i < FRAME_SIZE; i++)    			input[i] = pcm_data[i];    speex_encode(speex_encode_u->state, input, &speex_encode_u->bits);    /*Copy the bits to an array of char that can be written*///    nbBytes = speex_bits_write(&speex_encode_u->bits, cbits, 200);    int nbBytes = speex_bits_write(&speex_encode_u->bits, speex_data, 38);    printf("nbBytes = %d /n" ,nbBytes);//    /*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);//    printf("nbBytes = %d /n" ,nbBytes);//    /*Write the compressed data*///    //fwrite(cbits, 1, nbBytes, stdout);}

int main(int argc, char **argv){   char *inFile;   FILE *fin;   short in[FRAME_SIZE];   float input[FRAME_SIZE];   char cbits[2000];   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);   //printf("inited/n");   /*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, 2000);      /*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;}

BYTE* encodeSPEEX(signed short *data){	char *pCh = (char*)(&in_byte[0]);	speex_bits_reset(&inbits);	speex_encode_int(pEnc, data, &inbits);	speex_bits_write(&inbits, pCh, SPEEX_SIZE);	return (BYTE*)pCh;}

/* * Encode frames. */static pj_status_t spx_codec_encode( pjmedia_codec *codec, 				     const struct pjmedia_frame *input,				     unsigned output_buf_len, 				     struct pjmedia_frame *output){    struct spx_private *spx;    unsigned samples_per_frame;    int tx = 0;    spx_int16_t *pcm_in = (spx_int16_t*)input->buf;    pj_size_t nsamples;    spx = (struct spx_private*) codec->codec_data;    if (input->type != PJMEDIA_FRAME_TYPE_AUDIO) {	output->size = 0;	output->buf = NULL;	output->timestamp = input->timestamp;	output->type = input->type;	return PJ_SUCCESS;    }    nsamples = input->size >> 1;    samples_per_frame=spx_factory.speex_param[spx->param_id].samples_per_frame;    PJ_ASSERT_RETURN(nsamples % samples_per_frame == 0, 		     PJMEDIA_CODEC_EPCMFRMINLEN);    /* Flush all the bits in the struct so we can encode a new frame */    speex_bits_reset(&spx->enc_bits);    /* Encode the frames */    while (nsamples >= samples_per_frame) {	tx += speex_encode_int(spx->enc, pcm_in, &spx->enc_bits);	pcm_in += samples_per_frame;	nsamples -= samples_per_frame;    }    /* Check if we need not to transmit the frame (DTX) */    if (tx == 0) {	output->buf = NULL;	output->size = 0;	output->timestamp.u64 = input->timestamp.u64;	output->type = PJMEDIA_FRAME_TYPE_NONE;	return PJ_SUCCESS;    }    /* Check size. */    pj_assert(speex_bits_nbytes(&spx->enc_bits) <= (int)output_buf_len);    /* Copy the bits to an array of char that can be written */    output->size = speex_bits_write(&spx->enc_bits, 				    (char*)output->buf, output_buf_len);    output->type = PJMEDIA_FRAME_TYPE_AUDIO;    output->timestamp = input->timestamp;    return PJ_SUCCESS;}

OsStatus MpeSipxSpeexUWb::encode(const MpAudioSample* pAudioSamples,                              const int numSamples,                              int& rSamplesConsumed,                              unsigned char* pCodeBuf,                              const int bytesLeft,                              int& rSizeInBytes,                              UtlBoolean& sendNow,                              MpSpeechType& speechType){   int size = 0;   if (speechType == MP_SPEECH_SILENT && ms_bEnableVAD && mBufferLoad == 0)   {      // VAD must be enabled, do DTX      rSamplesConsumed = numSamples;      rSizeInBytes = 0;      sendNow = TRUE; // sends any unsent frames now      return OS_SUCCESS;   }   memcpy(&mpBuffer[mBufferLoad], pAudioSamples, sizeof(MpAudioSample)*numSamples);   mBufferLoad = mBufferLoad + numSamples;   assert(mBufferLoad <= 640);   // Check for necessary number of samples   if(mBufferLoad == 640)   {      speex_bits_reset(&mBits);      // We don't have echo data, but it should be possible to use the      // Speex echo cancelator in sipxtapi.      if(mDoPreprocess)         speex_preprocess(mpPreprocessState, mpBuffer, NULL);      speex_encode_int(mpEncoderState, mpBuffer, &mBits);      // Copy to the byte buffer      size = speex_bits_write(&mBits,(char*)pCodeBuf, bytesLeft);            // Reset the buffer count.      mBufferLoad = 0;      if (size > 0)      {         sendNow = true;      }   }   else   {      sendNow = false;   }   rSamplesConsumed = numSamples;   rSizeInBytes = size;      return OS_SUCCESS;}

uint16 t_speex_audio_encoder::encode(int16 *sample_buf, uint16 nsamples, 			uint8 *payload, uint16 payload_size, bool &silence){	assert(payload_size >= _max_payload_size);	silence = false;	speex_bits_reset(&speex_bits);                if (speex_encode_int(speex_enc_state, sample_buf, &speex_bits) == 0) 		silence = true;	return speex_bits_write(&speex_bits, (char *)payload, payload_size);}

static switch_status_t switch_speex_encode(switch_codec_t *codec,										   switch_codec_t *other_codec,										   void *decoded_data,										   uint32_t decoded_data_len,										   uint32_t decoded_rate, void *encoded_data, uint32_t *encoded_data_len, uint32_t *encoded_rate,										   unsigned int *flag){	struct speex_context *context = codec->private_info;	short *buf;	int is_speech = 1;	if (!context) {		return SWITCH_STATUS_FALSE;	}	buf = decoded_data;	if (context->pp) {		is_speech = speex_preprocess(context->pp, buf, NULL);	}	if (is_speech) {		is_speech = speex_encode_int(context->encoder_state, buf, &context->encoder_bits)			|| !context->codec_settings.dtx;	} else {		speex_bits_pack(&context->encoder_bits, 0, 5);	}	if (is_speech) {		switch_clear_flag(context, SWITCH_CODEC_FLAG_SILENCE);		*flag |= SWITCH_CODEC_FLAG_SILENCE_STOP;	} else {		if (switch_test_flag(context, SWITCH_CODEC_FLAG_SILENCE)) {			*encoded_data_len = 0;			*flag |= SWITCH_CODEC_FLAG_SILENCE;			return SWITCH_STATUS_SUCCESS;		}		switch_set_flag(context, SWITCH_CODEC_FLAG_SILENCE);		*flag |= SWITCH_CODEC_FLAG_SILENCE_START;	}	speex_bits_pack(&context->encoder_bits, 15, 5);	*encoded_data_len = speex_bits_write(&context->encoder_bits, (char *) encoded_data, context->encoder_frame_size);	speex_bits_reset(&context->encoder_bits);	(*encoded_data_len)--;	return SWITCH_STATUS_SUCCESS;}

    /* encode PCM data to speex frames */static void speexout_encode(t_speexout *x){    if ( x->x_bytesbuffered > x->x_framesize )    {      speex_bits_reset(&x->x_bits);            {        t_int sp=0, rp=0;               while( sp < x->x_framesize )          {             rp=(x->x_outp+sp)%IN_BUFFER_SIZE;             // post( "speexout~ : sp=%d : rp=%d", sp, rp );             x->x_encchunk[ sp++ ] = *(x->x_inbuf+rp);          }          speex_encode(x->x_encstate, x->x_encchunk, &x->x_bits);      }      x->x_outp = (x->x_outp+x->x_framesize)%IN_BUFFER_SIZE;      x->x_bytesbuffered -= x->x_framesize;      x->x_encsize = speex_bits_write(&x->x_bits, x->x_outbuf+1, OUT_BUFFER_SIZE );      if ( x->x_encsize < 127 )      {         *(x->x_outbuf) = (char)x->x_encsize;       }      else      {         post( "speexout~ : encoding error : frame is more than 127 bytes" );         x->x_encsize = -1;      }      x->x_bytesemitted += x->x_encsize;#ifdef DATADEBUG      {        t_int si;          printf( "speexout~ : encoded :  " );          for ( si=0; si<x->x_encsize; si++ )          {              printf( "%d ", *(x->x_outbuf+si) );          }          printf( "/n" );      }#endif    }    else    {      x->x_encsize = -1;    }}

static void enc_process(MSFilter *f){	SpeexEncState *s=(SpeexEncState*)f->data;	mblk_t *im;	int nbytes;	uint8_t *buf;	int frame_per_packet=1;	if (s->frame_size<=0)		return;	ms_filter_lock(f);	if (s->ptime>=20)	{		frame_per_packet = s->ptime/20;	}	if (frame_per_packet<=0)		frame_per_packet=1;	if (frame_per_packet>7) /* 7*20 == 140 ms max */		frame_per_packet=7;	nbytes=s->frame_size*2;	buf=(uint8_t*)alloca(nbytes*frame_per_packet);	while((im=ms_queue_get(f->inputs[0]))!=NULL){		ms_bufferizer_put(s->bufferizer,im);	}	while(ms_bufferizer_read(s->bufferizer,buf,nbytes*frame_per_packet)==nbytes*frame_per_packet){		mblk_t *om=allocb(nbytes*frame_per_packet,0);//too large...		int k;		SpeexBits bits;		speex_bits_init(&bits);		for (k=0;k<frame_per_packet;k++)		{			speex_encode_int(s->state,(int16_t*)(buf + (k*s->frame_size*2)),&bits);			s->ts+=s->frame_size;		}		speex_bits_insert_terminator(&bits);		k=speex_bits_write(&bits, (char*)om->b_wptr, nbytes*frame_per_packet);		om->b_wptr+=k;		mblk_set_timestamp_info(om,s->ts-s->frame_size);		ms_bufferizer_fill_current_metas(s->bufferizer, om);		ms_queue_put(f->outputs[0],om);		speex_bits_destroy(&bits);	}	ms_filter_unlock(f);}

int main(int argc, char **argv){    char *inFile;    FILE *fin;    short in[FRAME_SIZE];    float input[FRAME_SIZE];    char cbits[200];    int nbBytes;    /*保存编码的状态*/    void *state;    /*保存字节因此他们可以被speex常规读写*/    SpeexBits bits;    int i, tmp;    //新建一个新的编码状态在窄宽(narrowband)模式下    state = speex_encoder_init(&speex_nb_mode);    //设置质量为8(15kbps)    tmp=8;    speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);    inFile = argv[1];    fin = fopen(inFile, "r");    //初始化结构使他们保存数据    speex_bits_init(&bits);    while (1) {        //读入一帧16bits的声音        fread(in, sizeof(short), FRAME_SIZE, fin);        if (feof(fin))        break;        //把16bits的值转化为float,以便speex库可以在上面工作        for (i=0;i<FRAME_SIZE;i++)        input[i]=in[i];        //清空这个结构体里所有的字节,以便我们可以编码一个新的帧        speex_bits_reset(&bits);        //对帧进行编码        speex_encode(state, input, &bits);        //把bits拷贝到一个利用写出的char型数组        nbBytes = speex_bits_write(&bits, cbits, 200);        //首先写出帧的大小,这是sampledec文件需要的一个值,但是你的应用程序中可能不一样        fwrite(&nbBytes, sizeof(int), 1, stdout);        //写出压缩后的数组        fwrite(cbits, 1, nbBytes, stdout);    }    //释放编码器状态量    speex_encoder_destroy(state);    //释放bit_packing结构    speex_bits_destroy(&bits);    fclose(fin);    return 0;}

uint16 SpeexPlugin::encode(int16 *sample_buf, uint16 nsamples, uint8 *payload,		uint16 payload_size, bool &silence)		throw(OperationNotPerfomedException) {	if (payload_size < MAX_PAYLOAD_SIZE)		throw OperationNotPerfomedException("The buffer is not large enough");	if (!encoder)		throw OperationNotPerfomedException("Encoder not ready");	//	// Falta fazer o echo cancelling	//	//	//	if (usingEchoCancellation && !echoCapturedLast) {	//		uint32 samplesize = getSampleSize();	//		spx_int16_t *input_buf = new spx_int16_t[samplesize / 2];	//	//		for (int i = 0; i < getSampleSize() / 2; i++) {	//			input_buf[i] = sample_buf[i];	//		}	//	//		speex_echo_capture(echocancellation, input_buf, sample_buf);	//		echoCapturedLast = true;	//		delete input_buf;	//	}	bool preprocessing_silence = false;	if (preprocess) {		preprocessing_silence = !speex_preprocess_run(preprocess, sample_buf); //Garantir que o nsamples sera sempre o mesmo		bool speex_dsp_vad;		speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_GET_VAD,				&speex_dsp_vad);		if (!speex_dsp_vad)			preprocessing_silence = false;	}	silence = false;	speex_bits_reset(&encoder->bits);	silence = speex_encode_int(encoder->state, sample_buf, &encoder->bits) == 0;	silence = silence || preprocessing_silence;	return speex_bits_write(&encoder->bits, (char *) payload, payload_size);}

void gviSpursSpeexEncode(SpursSpeexTaskOutput *spuTaskOut){		short *inBuffer;	float *speexBuffer;	char *outBuffer;	unsigned int i;	spuTaskOut->mSpeexEncodedFrameSize = 0;	spuTaskOut->mSpeexInitialized = 1;	spuTaskOut->mSpeexSamplesPerFrame = 0;	spuTaskOut->mSpeexReturnCode = 0;	spuTaskOut->mSpeexOutBufferSize = 0;	speexBuffer = (float *)memalign(16, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(float));	inBuffer = (short *)memalign(16, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(short));	outBuffer = (char *)memalign(16, gviSpursSpeexTaskDesc.mOutputBufferSize);		memset(speexBuffer, 0, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(float));	memset(inBuffer, 0, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(short));	memset(outBuffer, 0, gviSpursSpeexTaskDesc.mOutputBufferSize);	cellDmaGet(inBuffer, (uint64_t)gviSpursSpeexTaskDesc.mInputBuffer, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(short), DMA_TAG(1), 0,0);	cellDmaWaitTagStatusAll(DMA_MASK(1));			// convert the input to floats for encoding	for(i = 0 ; i < gviSpursSpeexTaskDesc.mInputBufferSize ; i++)		speexBuffer[i] = inBuffer[i];	// (re)initialize the bits struct	speex_bits_init_buffer(&gviSpursSpeexBits,gviSpursSpeexBitsBuffer,sizeof(gviSpursSpeexBitsBuffer));	// flush the bits	speex_bits_reset(&gviSpursSpeexBits);	// encode the frame	speex_encode(gviSpursSpeexStateBuffer, speexBuffer, &gviSpursSpeexBits);	// write the bits to the output	spuTaskOut->mSpeexOutBufferSize = speex_bits_write(&gviSpursSpeexBits, (char *)outBuffer, gviSpursSpeexTaskDesc.mEncodedFrameSize);	//spuDebugPrintf("[Speex][SPU] transferring data back, output size should be: %d/n", gviSpursSpeexTaskDesc.mOutputBufferSize>16?gviSpursSpeexTaskDesc.mOutputBufferSize:16);	cellDmaPut(outBuffer, (uint64_t)gviSpursSpeexTaskDesc.mOutputBuffer, gviSpursSpeexTaskDesc.mOutputBufferSize, DMA_TAG(1), 0, 0);	cellDmaWaitTagStatusAll(DMA_MASK(1));	//spuDebugPrintf("[Speex][SPU] done transferring data back/n");	free(speexBuffer);	free(inBuffer);	free(outBuffer);	spuTaskOut->mSpeexReturnCode = 0;}

static int encode(struct auenc_state *st, uint8_t *buf,		  size_t *len, const int16_t *sampv, size_t sampc){	const size_t n = st->channels * st->frame_size;	int ret, r;	if (*len < 128)		return ENOMEM;	/* VAD */	if (!sampv || !sampc) {		/* 5 zeros interpreted by Speex as silence (submode 0) */		speex_bits_pack(&st->bits, 0, 5);		goto out;	}	/* Handle multiple Speex frames in one RTP packet */	while (sampc > 0) {		/* Assume stereo */		if (2 == st->channels) {			speex_encode_stereo_int((int16_t *)sampv,						st->frame_size, &st->bits);		}		ret = speex_encode_int(st->enc, (int16_t *)sampv, &st->bits);		if (1 != ret) {			warning("speex: speex_encode_int: ret=%d/n", ret);		}		sampc -= n;		sampv += n;	} out:	/* Terminate bit stream */	speex_bits_pack(&st->bits, 15, 5);	r = speex_bits_write(&st->bits, (char *)buf, (int)*len);	*len = r;	speex_bits_reset(&st->bits);	return 0;}

int AudioInput::encodeSpeexFrame(short *psSource, unsigned char *buffer) {	int vbr = 0;	speex_encoder_ctl(esSpeex, SPEEX_GET_VBR_MAX_BITRATE, &vbr);	if (vbr != iAudioQuality) {		vbr = iAudioQuality;		speex_encoder_ctl(esSpeex, SPEEX_SET_VBR_MAX_BITRATE, &vbr);	}	if (! bPreviousVoice)		speex_encoder_ctl(esSpeex, SPEEX_RESET_STATE, NULL);	speex_encode_int(esSpeex, psSource, &sbBits);	int len = speex_bits_write(&sbBits, reinterpret_cast<char *>(buffer), 127);	iBitrate = len * 50 * 8;	speex_bits_reset(&sbBits);	return len;}

void gviSpeexEncode(GVByte * out, const GVSample * in){	int bytesWritten;	int i;	// convert the input to floats for encoding	for(i = 0 ; i < gviSpeexSamplesPerFrame ; i++)		gviSpeexBuffer[i] = in[i];	// flush the bits	speex_bits_reset(&gviSpeexBits);	// encode the frame	speex_encode(gviSpeexEncoderState, gviSpeexBuffer, &gviSpeexBits);	// write the bits to the output	bytesWritten = speex_bits_write(&gviSpeexBits, (char *)out, gviSpeexEncodedFrameSize);	GS_ASSERT(bytesWritten == gviSpeexEncodedFrameSize);}