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

hsBool plSpeex::Init(Mode mode) {    int enh = 1;        // setup speex    speex_bits_init(fBits);    fBitsInit = true;    if(mode == kNarrowband)    {        fEncoderState = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));                         // narrowband        fDecoderState = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));    }    else if(mode == kWideband)    {        fEncoderState = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));        fDecoderState = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));    }        speex_encoder_ctl(fEncoderState, SPEEX_GET_FRAME_SIZE, &fFrameSize);            // get frame size    speex_encoder_ctl(fEncoderState, SPEEX_SET_COMPLEXITY, &fComplexity);           // 3    speex_encoder_ctl(fEncoderState, SPEEX_SET_SAMPLING_RATE, &fSampleRate);        // 8 khz    speex_encoder_ctl(fEncoderState, SPEEX_SET_VBR_QUALITY, &fQuality);             // 7    speex_encoder_ctl(fEncoderState, SPEEX_SET_VBR, &fVBR);                         // use variable bit rate    speex_encoder_ctl(fEncoderState, SPEEX_SET_ABR, &fAverageBitrate);              // default to 8kb        speex_decoder_ctl(fDecoderState, SPEEX_SET_ENH, &fENH);                         // perceptual enhancement                   fInitialized = true;    return true;}

void SpeexPlugin::buildDecoder(std::string modeName)		throw(OperationNotPerfomedException) {	if (decoder)		throw OperationNotPerfomedException("The decoder already exists. "			"Please call endDecoder before perform this task");	SpeexMode mode = getMode(modeName);	if (mode == INVALID_MODE)		throw OperationNotPerfomedException("Invalid Mode");	decoder = new HalfCodec;	decoder->mode = mode;	speex_bits_init(&decoder->bits);	switch (mode) {	case MODE_NB:		decoder->state = speex_decoder_init(&speex_nb_mode);		break;	case MODE_WB:		decoder->state = speex_decoder_init(&speex_wb_mode);		break;	case MODE_UWB:		decoder->state = speex_decoder_init(&speex_uwb_mode);		break;	};}

void gviSpursSpeexDecoderInitialize(SpursSpeexTaskOutput *spuTaskOut){	void * decoder = gviSpursSpeexStateBuffer;	int perceptualEnhancement = 1;	// create a new decoder state	if (gviSpursSpeexTaskDesc.mSamplesPerSecond == GVRate_8KHz)		speex_decoder_init(&speex_nb_mode, decoder);	else if (gviSpursSpeexTaskDesc.mSamplesPerSecond == GVRate_16KHz)		speex_decoder_init(&speex_wb_mode, decoder);	else	{		//spuDebugPrintf("[Speex][SPU] Error: invalid sample rate!/n");		spuTaskOut->mSpeexReturnCode = -1;	}	if(!decoder)	{		//spuDebugPrintf("[Speex][SPU] Error: initializing decoder failed!/n");		spuTaskOut->mSpeexReturnCode = -2;	}	// turn on the perceptual enhancement	speex_decoder_ctl(decoder, SPEEX_SET_ENH, &perceptualEnhancement);	spuTaskOut->mSpeexReturnCode = 0;}

JNIEXPORT void JNICALL FUNCSPEEX(initDecode)(JNIEnv* env, jobject obj) {	speex_bits_init(&dbits);	dec_state = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));	speex_decoder_ctl(dec_state, SPEEX_GET_FRAME_SIZE, &dec_frame_size);	int tmp = 1;	speex_decoder_ctl(dec_state, SPEEX_SET_ENH, &tmp);}

AudioDecoderSpeex::AudioDecoderSpeex()    : _speex_dec_state(speex_decoder_init(&speex_wb_mode)) {    if (!_speex_dec_state) {        throw MediaException(_("AudioDecoderSpeex: state initialization failed."));    }    speex_bits_init(&_speex_bits);    speex_decoder_ctl(_speex_dec_state, SPEEX_GET_FRAME_SIZE, &_speex_framesize);#ifdef RESAMPLING_SPEEX    int err = 0;    _resampler = speex_resampler_init(1, 16000, 44100,        SPEEX_RESAMPLER_QUALITY_DEFAULT, &err);    if (err != RESAMPLER_ERR_SUCCESS) {        throw MediaException(_("AudioDecoderSpeex: initialization failed."));    }    spx_uint32_t num = 0, den = 0;    speex_resampler_get_ratio (_resampler, &num, &den);    assert(num && den);    boost::rational<boost::uint32_t> numsamples(den, num);    numsamples *= _speex_framesize * 2 /* convert to stereo */;    _target_frame_size = boost::rational_cast<boost::uint32_t>(numsamples);#endif}

JNIEXPORT jint JNICALL Java_com_purplefrog_speexjni_SpeexDecoder_allocate  (JNIEnv *env, jclass cls, jint wideband){    int slot = allocate_slot(&slots);    //    slots.slots[slot] = malloc(sizeof(struct Slot));    struct Slot* gob = slots.slots[slot];    //    speex_bits_init(&gob->bits);    const SpeexMode * mode;    switch (wideband) {    case 1:	mode = &speex_wb_mode;	break;    case 2:	mode = &speex_uwb_mode;	break;    default:	mode = &speex_nb_mode;	break;    }    gob->state = speex_decoder_init(mode);    return slot;}

void decode(int header) {  FILE * fin = fopen("audiopacket2.spx", "r");  FILE * fout = fopen("decoded_audio.raw", "w");  int i;  short out[FRAME_SIZE];  float output[FRAME_SIZE];  char cbits[331-20];  SpeexBits bits;  void * state;    state = speex_decoder_init(&speex_nb_mode);  speex_bits_init(&bits);  while(1) {    if(feof(fin))      break;    /* on lit 307 octets (un paquet) vers cbits */    fread(cbits, 1, 331-20, fin);    /* on le copie vers une structure bit-stream */    speex_bits_read_from(&bits, cbits+header, 331-20-header);    /* on decode */    speex_decode(state, &bits, output);    for(i=0 ; i< FRAME_SIZE ; i++)      out[i]= output[i];    fwrite(out, sizeof(short), FRAME_SIZE, fout);  }}

//*****************************************************************************////! Initialize the decoder's state to prepare for decoding new frames.//!//! This function will initializes the decoder so that it is prepared to start//! receiving frames to decode.//!//! /return This function returns 0.////*****************************************************************************int32_tSpeexDecodeInit(void){    int iTemp;    //    // Clear out the flags for this instance.    //    g_sSpeexDecoder.ui32Flags = 0;    //    // Create a new decoder state in narrow band mode.    //    g_sSpeexDecoder.pvState = speex_decoder_init(&speex_nb_mode);    //    // Disable enhanced decoding to reduce processing requirements.    //    iTemp = 0;    speex_decoder_ctl(g_sSpeexDecoder.pvState, SPEEX_SET_ENH, &iTemp);    //    // Initialization of the structure that holds the bits.    //    speex_bits_init(&g_sSpeexDecoder.sBits);    return(0);}

static av_cold int libspeex_decode_init(AVCodecContext *avctx){    LibSpeexContext *s = avctx->priv_data;    const SpeexMode *mode;    // defaults in the case of a missing header    if (avctx->sample_rate <= 8000)        mode = &speex_nb_mode;    else if (avctx->sample_rate <= 16000)        mode = &speex_wb_mode;    else        mode = &speex_uwb_mode;    if (avctx->extradata_size >= 80)        s->header = speex_packet_to_header(avctx->extradata, avctx->extradata_size);    avctx->sample_fmt = AV_SAMPLE_FMT_S16;    if (s->header) {        avctx->sample_rate = s->header->rate;        avctx->channels    = s->header->nb_channels;        s->frame_size      = s->header->frame_size;        mode = speex_lib_get_mode(s->header->mode);        if (!mode) {            av_log(avctx, AV_LOG_ERROR, "Unknown Speex mode %d", s->header->mode);            return AVERROR_INVALIDDATA;        }    } else        av_log(avctx, AV_LOG_INFO, "Missing Speex header, assuming defaults./n");    if (avctx->channels > 2) {        av_log(avctx, AV_LOG_ERROR, "Only stereo and mono are supported./n");        return AVERROR(EINVAL);    }    speex_bits_init(&s->bits);    s->dec_state = speex_decoder_init(mode);    if (!s->dec_state) {        av_log(avctx, AV_LOG_ERROR, "Error initializing libspeex decoder./n");        return -1;    }    if (!s->header) {        speex_decoder_ctl(s->dec_state, SPEEX_GET_FRAME_SIZE, &s->frame_size);    }    if (avctx->channels == 2) {        SpeexCallback callback;        callback.callback_id = SPEEX_INBAND_STEREO;        callback.func = speex_std_stereo_request_handler;        callback.data = &s->stereo;        s->stereo = (SpeexStereoState)SPEEX_STEREO_STATE_INIT;        speex_decoder_ctl(s->dec_state, SPEEX_SET_HANDLER, &callback);    }    avcodec_get_frame_defaults(&s->frame);    avctx->coded_frame = &s->frame;    return 0;}

static void dec_preprocess(MSFilter *f){	DecState *s=(DecState*)f->data;	const SpeexMode *mode=NULL;	int modeid;	switch(s->rate){		case 8000:	        modeid = SPEEX_MODEID_NB;    /* rate = 8000Hz */			break;		case 16000:	        modeid = SPEEX_MODEID_WB;    /* rate = 16000Hz */			break;			/* should be supported in the future */		case 32000:	        modeid = SPEEX_MODEID_UWB;   /* rate = 32000Hz */			break;		default:			ms_error("Unsupported rate for speex decoder (back to default rate=8000).");			modeid=SPEEX_MODEID_NB;	}	/* warning: speex_lib_get_mode() is not available on speex<1.1.12 */	mode = speex_lib_get_mode(modeid);	s->state=speex_decoder_init(mode);	speex_mode_query(mode,SPEEX_MODE_FRAME_SIZE,&s->frsz);	if (s->penh==1)		speex_decoder_ctl (s->state, SPEEX_SET_ENH, &s->penh);	s->sample_time=0;}

extern "C" JNIEXPORT jint JNICALL Java_com_haitou_xiaoyoupai_imservice_support_audio_Speex_open(    JNIEnv *env, jobject obj, jint compression) {    int tmp = 0;    if (codec_open++ != 0)        return (jint) 0;    speex_bits_init(&ebits);    speex_bits_init(&dbits);    enc_state = speex_encoder_init(&speex_nb_mode);    dec_state = speex_decoder_init(&speex_nb_mode);    tmp = compression;    speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);    speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &enc_frame_size);    speex_decoder_ctl(dec_state, SPEEX_GET_FRAME_SIZE, &dec_frame_size);    SpeexPreprocessState * m_st;    m_st = speex_preprocess_state_init(enc_frame_size, 8000);    int denoise = 1;    int noiseSuppress = -25;    speex_preprocess_ctl(m_st, SPEEX_PREPROCESS_SET_DENOISE, &denoise);    speex_preprocess_ctl(m_st, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS,                         &noiseSuppress);    return (jint) 0;}

int main(int argc, char **argv){   char *outFile;   FILE *fout;   /*Holds the audio that will be written to file (16 bits per sample)*/   short out[FRAME_SIZE];   /*Speex handle samples as float, so we need an array of floats*/   float output[FRAME_SIZE];   char cbits[200];   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;   /*Create a new decoder state in narrowband mode*/   state = speex_decoder_init(&speex_nb_mode);   /*Set the perceptual enhancement on*/   tmp=1;   speex_decoder_ctl(state, SPEEX_SET_ENH, &tmp);   outFile = argv[1];   fout = fopen(outFile, "w");   /*Initialization of the structure that holds the bits*/   speex_bits_init(&bits);   while (1)   {      /*Read the size encoded by sampleenc, this part will likely be        different in your application*/      fread(&nbBytes, sizeof(int), 1, stdin);      fprintf (stderr, "nbBytes: %d/n", nbBytes);      if (feof(stdin))         break;      /*Read the "packet" encoded by sampleenc*/      fread(cbits, 1, nbBytes, stdin);      /*Copy the data into the bit-stream struct*/      speex_bits_read_from(&bits, cbits, nbBytes);      /*Decode the data*/      speex_decode(state, &bits, output);      /*Copy from float to short (16 bits) for output*/      for (i=0;i<FRAME_SIZE;i++)         out[i]=output[i];      /*Write the decoded audio to file*/      fwrite(out, sizeof(short), FRAME_SIZE, fout);   }   /*Destroy the decoder state*/   speex_decoder_destroy(state);   /*Destroy the bit-stream truct*/   speex_bits_destroy(&bits);   fclose(fout);   return 0;}

/* * Open codec. */static pj_status_t spx_codec_open( pjmedia_codec *codec, 				   pjmedia_codec_param *attr ){    struct spx_private *spx;    int id, tmp;    spx = (struct spx_private*) codec->codec_data;    id = spx->param_id;    /*      * Create and initialize encoder.      */    spx->enc = speex_encoder_init(spx_factory.speex_param[id].mode);    if (!spx->enc)	return PJMEDIA_CODEC_EFAILED;    speex_bits_init(&spx->enc_bits);    /* Set the quality*/    if (spx_factory.speex_param[id].quality != -1) {	speex_encoder_ctl(spx->enc, SPEEX_SET_QUALITY, 			  &spx_factory.speex_param[id].quality);    }    /* Sampling rate. */    tmp = attr->info.clock_rate;    speex_encoder_ctl(spx->enc, SPEEX_SET_SAMPLING_RATE, 		      &spx_factory.speex_param[id].clock_rate);    /* VAD */    tmp = (attr->setting.vad != 0);    speex_encoder_ctl(spx->enc, SPEEX_SET_VAD, &tmp);    speex_encoder_ctl(spx->enc, SPEEX_SET_DTX, &tmp);    /* Complexity */    if (spx_factory.speex_param[id].complexity != -1) {	speex_encoder_ctl(spx->enc, SPEEX_SET_COMPLEXITY, 			  &spx_factory.speex_param[id].complexity);    }    /*      * Create and initialize decoder.      */    spx->dec = speex_decoder_init(spx_factory.speex_param[id].mode);    if (!spx->dec) {	spx_codec_close(codec);	return PJMEDIA_CODEC_EFAILED;    }    speex_bits_init(&spx->dec_bits);    /* Sampling rate. */    speex_decoder_ctl(spx->dec, SPEEX_SET_SAMPLING_RATE, 		      &spx_factory.speex_param[id].clock_rate);    /* PENH */    tmp = attr->setting.penh;    speex_decoder_ctl(spx->dec, SPEEX_SET_ENH, &tmp);    return PJ_SUCCESS;}

speex_decoder::speex_decoder(speex_profile p){    speex_bits_init(&bits_);    decoder_state_ = speex_decoder_init(p == wideband_speex_profile ? &speex_wb_mode : &speex_nb_mode);    int fs;    do_decoder_ctl(decoder_state_, SPEEX_GET_FRAME_SIZE, &fs);    block_size_ = fs;}

	speex2pcm_int()	{		state = speex_decoder_init(&speex_nb_mode);		int tmp=1;		speex_decoder_ctl(state, SPEEX_SET_ENH, &tmp);		speex_bits_init(&bits);		speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &frame_size);		out  = new short[ frame_size ];	}

void init_speex_decoder() {    if (gDecoderState == NULL) {        gDecoderState = speex_decoder_init(&speex_nb_mode);        int tmp = 1;        speex_decoder_ctl(gDecoderState, SPEEX_SET_ENH, &tmp);        tmp = kNetworkAudioSampleRate;        speex_decoder_ctl(gDecoderState, SPEEX_SET_SAMPLING_RATE, &tmp);        speex_bits_init(&gDecoderBits);    }}

int tdav_codec_speex_open(tmedia_codec_t* self){	static int quality = SPEEX_DEFAULT_QUALITY;	tdav_codec_speex_t* speex = (tdav_codec_speex_t*)self;		switch(speex->type){		case tdav_codec_speex_type_nb:			speex->encoder.state = speex_encoder_init(&speex_nb_mode);			speex->decoder.state = speex_decoder_init(&speex_nb_mode);			break;		case tdav_codec_speex_type_wb:			speex->encoder.state = speex_encoder_init(&speex_wb_mode);			speex->decoder.state = speex_decoder_init(&speex_wb_mode);			break;		case tdav_codec_speex_type_uwb:			speex->encoder.state = speex_encoder_init(&speex_uwb_mode);			speex->decoder.state = speex_decoder_init(&speex_uwb_mode);			break;		default:			TSK_DEBUG_ERROR("Not implemented");			return -2;	}	speex_decoder_ctl(speex->decoder.state, SPEEX_GET_FRAME_SIZE, &speex->decoder.size);	speex->decoder.size *= sizeof(spx_int16_t);	if(!(speex->decoder.buffer = tsk_calloc(speex->decoder.size, 1))){		speex->decoder.size = speex->decoder.size = 0;		TSK_DEBUG_ERROR("Failed to allocate new buffer");		return -3;	}	speex_encoder_ctl(speex->encoder.state, SPEEX_SET_QUALITY, &quality);	speex_encoder_ctl(speex->encoder.state, SPEEX_GET_FRAME_SIZE, &speex->encoder.size);	speex_bits_init(&speex->encoder.bits);	speex_bits_init(&speex->decoder.bits);	speex_bits_reset(&speex->encoder.bits);	speex_bits_reset(&speex->decoder.bits);	return 0;}

static int decode_update(struct audec_state **adsp,			 const struct aucodec *ac, const char *fmtp){	struct audec_state *st;	int err = 0;	(void)fmtp;	if (!adsp || !ac)		return EINVAL;	if (*adsp)		return 0;	st = mem_zalloc(sizeof(*st), decode_destructor);	if (!st)		return ENOMEM;	st->frame_size = ac->srate * SPEEX_PTIME / 1000;	st->channels = ac->ch;	/* Decoder */	st->dec = speex_decoder_init(resolve_mode(ac->srate));	if (!st->dec) {		err = ENOMEM;		goto out;	}	speex_bits_init(&st->bits);	if (2 == st->channels) {		/* Stereo. */		st->stereo.balance = 1;		st->stereo.e_ratio = .5f;		st->stereo.smooth_left = 1;		st->stereo.smooth_right = 1;		st->callback.callback_id = SPEEX_INBAND_STEREO;		st->callback.func = speex_std_stereo_request_handler;		st->callback.data = &st->stereo;		speex_decoder_ctl(st->dec, SPEEX_SET_HANDLER,				  &st->callback);	}	decoder_config(st->dec); out:	if (err)		mem_deref(st);	else		*adsp = st;	return err;}

static void *process_header (struct spx_data *data){	void *st;	const SpeexMode *mode;	int modeID;	SpeexCallback callback;	int enhance = ENHANCE_AUDIO;	data->header = speex_packet_to_header ((char*)data->op.packet,			data->op.bytes);	if (!data->header) {		decoder_error (&data->error, ERROR_FATAL, 0,				"Can't open speex file: can't read header");		return NULL;	}	if (data->header->mode >= SPEEX_NB_MODES) {		decoder_error (&data->error, ERROR_FATAL, 0,				"Can't open speex file: Mode number %"PRId32				" does not exist in this version",				data->header->mode);		return NULL;	}	modeID = data->header->mode;	mode = speex_mode_list[modeID];	if (mode->bitstream_version < data->header->mode_bitstream_version) {		decoder_error (&data->error, ERROR_FATAL, 0,				"Can't open speex file: The file was encoded "				"with a newer version of Speex.");		return NULL;	}	if (mode->bitstream_version > data->header->mode_bitstream_version) {		decoder_error (&data->error, ERROR_FATAL, 0,				"Can't open speex file: The file was encoded "				"with an older version of Speex.");		return NULL;	}	st = speex_decoder_init (mode);	speex_decoder_ctl(st, SPEEX_SET_ENH, &enhance);	speex_decoder_ctl(st, SPEEX_GET_FRAME_SIZE, &data->frame_size);	callback.callback_id = SPEEX_INBAND_STEREO;	callback.func = speex_std_stereo_request_handler;	callback.data = &data->stereo;	speex_decoder_ctl(st, SPEEX_SET_HANDLER, &callback);	speex_decoder_ctl(st, SPEEX_SET_SAMPLING_RATE, &data->header->rate);	return st;}

GVBool gviSpeexNewDecoder(GVDecoderData * data){	void * decoder;	int perceptualEnhancement = 1;		// create a new decoder state	if (gviGetSampleRate() == GVRate_8KHz)		decoder = speex_decoder_init(&speex_nb_mode);	else if (gviGetSampleRate() == GVRate_16KHz)		decoder = speex_decoder_init(&speex_wb_mode);	else		return GVFalse;	if(!decoder)		return GVFalse;	// turn on the perceptual enhancement	speex_decoder_ctl(decoder, SPEEX_SET_ENH, &perceptualEnhancement);	*data = decoder;	return GVTrue;}

void ms_speex_dec_init_core(MSSpeexDec *obj,const SpeexMode *mode){	int pf=1;		obj->speex_state=speex_decoder_init(mode);	speex_bits_init(&obj->bits);	/* enable the perceptual post filter */	speex_decoder_ctl(obj->speex_state,SPEEX_SET_PF, &pf);		speex_mode_query(mode, SPEEX_MODE_FRAME_SIZE, &obj->frame_size);		obj->initialized=1;}

AudioOutputSpeech::AudioOutputSpeech(boost::shared_ptr<ClientUser> user, MessageHandler::UDPMessageType type) : AudioOutputUser(user->qsName) {	int err;	p = user;	umtType = type;	unsigned int srate = 0;	cCodec = NULL;	cdDecoder = NULL;	if (umtType != MessageHandler::UDPVoiceSpeex) {		srate = SAMPLE_RATE;		iFrameSize = srate / 100;		dsSpeex = NULL;	} else {		speex_bits_init(&sbBits);		dsSpeex = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));		int iArg=1;		speex_decoder_ctl(dsSpeex, SPEEX_SET_ENH, &iArg);		speex_decoder_ctl(dsSpeex, SPEEX_GET_FRAME_SIZE, &iFrameSize);		speex_decoder_ctl(dsSpeex, SPEEX_GET_SAMPLING_RATE, &srate);	}	if (srate != SAMPLE_RATE)		srs = speex_resampler_init(1, srate, SAMPLE_RATE, 3, &err);	else		srs = NULL;	iOutputSize = static_cast<unsigned int>(ceilf(static_cast<float>(iFrameSize * SAMPLE_RATE) / static_cast<float>(SAMPLE_RATE)));	iBufferOffset = iBufferFilled = iLastConsume = 0;	bLastAlive = true;	iMissCount = 0;	iMissedFrames = 0;	ucFlags = 0xFF;	jbJitter = jitter_buffer_init(iFrameSize);	int margin = g.s.iJitterBufferSize * iFrameSize;	jitter_buffer_ctl(jbJitter, JITTER_BUFFER_SET_MARGIN, &margin);	fFadeIn = new float[iFrameSize];	fFadeOut = new float[iFrameSize];	float mul = static_cast<float>(M_PI / (2.0 * static_cast<double>(iFrameSize)));	for (unsigned int i=0;i<iFrameSize;++i)		fFadeIn[i] = fFadeOut[iFrameSize-i-1] = sinf(static_cast<float>(i) * mul);}

static int speex_decoder_construct(struct ast_trans_pvt *pvt, const SpeexMode *profile){	struct speex_coder_pvt *tmp = pvt->pvt;		if (!(tmp->speex = speex_decoder_init(profile)))		return -1;	speex_bits_init(&tmp->bits);	speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);	if (enhancement)		speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);	return 0;}

static int speextolin_new(struct ast_trans_pvt *pvt){	struct speex_coder_pvt *tmp = pvt->pvt;		if (!(tmp->speex = speex_decoder_init(&speex_nb_mode)))		return -1;	speex_bits_init(&tmp->bits);	speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);	if (enhancement)		speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);	return 0;}

NS_IMETHODIMPotSpeexDecoder::SourceSet(otISource *source){  nsresult rv;  PRUint32 sampleRate;  PRUint16 ptime;  if (!source) {    if (mTarget)      mTarget->SourceSet(nsnull);    FreeData();    return NS_OK;  }  rv = source->GetCodecInfo(getter_AddRefs(mCodecInfo));  if (NS_FAILED(rv))    return rv;  rv = mCodecInfo->GetClockrate(&sampleRate);  if (NS_FAILED(rv))    return rv;  rv = mCodecInfo->GetPtime(&ptime);  if (NS_FAILED(rv))    return rv;  mFrameSize = 2*ptime*sampleRate/1000;  mSpeexState = speex_decoder_init(sampleRate == 8000 ? &speex_nb_mode :                                   sampleRate == 16000 ? &speex_wb_mode :                                   &speex_uwb_mode);  if (!mSpeexState) {    FreeData();    return NS_ERROR_OUT_OF_MEMORY;  }  mSpeexBits = new SpeexBits();  if (!mSpeexBits) {    FreeData();    return NS_ERROR_OUT_OF_MEMORY;  }  speex_bits_init(mSpeexBits);  return NS_OK;}

JNIEXPORT jint JNICALL Java_com_speex_encode_Speex_open  (JNIEnv *env, jobject obj, jint compression) {	int tmp;	if (codec_open++ != 0)		return (jint)0;	speex_bits_init(&ebits);	speex_bits_init(&dbits);	enc_state = speex_encoder_init(&speex_nb_mode); 	dec_state = speex_decoder_init(&speex_nb_mode); 	tmp = compression;	speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);	speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &enc_frame_size);	speex_decoder_ctl(dec_state, SPEEX_GET_FRAME_SIZE, &dec_frame_size);	return (jint)0;}

QSpeexCodecPtr qSpeexCreateHandle(void){	QSpeexCodecPtr handle = (QSpeexCodecPtr) malloc(sizeof(QSpeexCodec));	if (!handle) return handle;		handle->frameSize = 320;  // assume wideband		// Visual Studio: need to use "speex_lib_get_mode()" instead of 	// referring directly to "speex_wb_mode"	handle->encState = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));	handle->decState = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));		speex_bits_init(&handle->encBits);	speex_bits_init(&handle->decBits);		// The sampling rate isn't used, but we add it since the example code does (speexclient.c)	speex_jitter_init(&handle->jitter, handle->decState, SAMPLING_RATE);	handle->fake_timestamp = 0;	return handle;}

static ErlDrvData codec_drv_start(ErlDrvPort port, char *buff){	int tmp;	codec_data* d = (codec_data*)driver_alloc(sizeof(codec_data));	d->port = port;	speex_bits_init(&d->bits);	/* FIXME hardcoded narrowband mode (speex_wb_mode, speex_uwb_mode) */	d->estate = speex_encoder_init(&speex_nb_mode);	d->dstate = speex_decoder_init(&speex_nb_mode);//	tmp=8;//	speex_encoder_ctl(d->estate, SPEEX_SET_QUALITY, &tmp);	tmp=3;	speex_encoder_ctl(d->estate, SPEEX_SET_COMPLEXITY, &tmp);//	tmp=8000;//	speex_encoder_ctl(d->estate, SPEEX_SET_SAMPLING_RATE, &tmp);	tmp=1;	speex_decoder_ctl(d->dstate, SPEEX_SET_ENH, &tmp);	set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);	return (ErlDrvData)d;}

//function sets up the encoder/decoder structs and buffers, returns required samples/frameint setup_codecs(){  //Init the state structs in narrowband (8 kHz) mode  enc_state = speex_encoder_init(&speex_wb_mode);  dec_state = speex_decoder_init(&speex_wb_mode);  //Set the quality to 8 (28 kbps)  int tmp=QUALITY;  speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);    //enable the perceptual enhancer (reduce noise)  tmp = 1;  speex_decoder_ctl(dec_state, SPEEX_SET_ENH, &tmp);    //Init the buffers  speex_bits_init(&enc_bits);  speex_bits_init(&dec_bits);    //get the frame size needed for specified settings  speex_encoder_ctl(enc_state,SPEEX_GET_FRAME_SIZE,&tmp);   return tmp;  //return the frame size}