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

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);}

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;}

/* * 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;}

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);    }}

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;}

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 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;}

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;}

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;}

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;}

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}

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;}

//*****************************************************************************////! 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 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;}

int speex_std_enh_request_handler(SpeexBits *bits, void *state, void *data){   int enh;   enh = speex_bits_unpack_unsigned(bits, 1);   speex_decoder_ctl(data, SPEEX_SET_ENH, &enh);   return 0;}

static int decode_audio(sh_audio_t *sh, unsigned char *buf,                        int minlen, int maxlen) {  double pts;  context_t *ctx = sh->context;  int len, framelen, framesamples;  char *packet;  int i, err;  speex_decoder_ctl(ctx->dec_context, SPEEX_GET_FRAME_SIZE, &framesamples);  framelen = framesamples * ctx->hdr->nb_channels * sizeof(short);  if (maxlen < ctx->hdr->frames_per_packet * framelen) {    mp_msg(MSGT_DECAUDIO, MSGL_V, "maxlen too small in decode_audio/n");    return -1;  }  len = ds_get_packet_pts(sh->ds, (unsigned char **)&packet, &pts);  if (len <= 0) return -1;  if (sh->pts == MP_NOPTS_VALUE)    sh->pts = 0;  if (pts != MP_NOPTS_VALUE) {    sh->pts = pts;    sh->pts_bytes = 0;  }  speex_bits_read_from(&ctx->bits, packet, len);  i = ctx->hdr->frames_per_packet;  do {    err = speex_decode_int(ctx->dec_context, &ctx->bits, (short *)buf);    if (err == -2)      mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Error decoding file./n");    if (ctx->hdr->nb_channels == 2)      speex_decode_stereo_int((short *)buf, framesamples, &ctx->stereo);    buf = &buf[framelen];  } while (--i > 0);  sh->pts_bytes += ctx->hdr->frames_per_packet * framelen;  return ctx->hdr->frames_per_packet * framelen;}

int speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *current_timestamp, void** userData){   int i;   int jbRet;	/* results returned by the JB */   int ourRet;	/* result that we will return */   spx_int32_t activity;   char data[2048];   JitterBufferPacket packet;   packet.data = data;   packet.len = 2048;  /* AAAAARGH: it took a week to find and add this missing line */      if (jitter->valid_bits)   {      /* Try decoding last received packet */      jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);      if (jbRet == 0)      {         jitter_buffer_tick(jitter->packets);         return 1;      } else {         jitter->valid_bits = 0;      }   }   jbRet = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, NULL);      if (jbRet != JITTER_BUFFER_OK)   {	  /* no packet found, so no corresponding user-data */      *userData = NULL;      /* No packet found... extrapolate one */      /*fprintf (stderr, "lost/late frame/n");*/      /*Packet is late or lost*/      speex_decode_int(jitter->dec, NULL, out);	  	  ourRet = 2;   } else {	  /* found a packet, so there is corresponding user-data */	  *userData = (void*)(packet.user_data);         speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);      /* Decode packet */      jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);      if (jbRet == 0) {         ourRet = 0;		         jitter->valid_bits = 1;      } else {         /* Error while decoding */         ourRet = 3;         for (i=0;i<jitter->frame_size;i++) out[i]=0;      }   }   speex_decoder_ctl(jitter->dec, SPEEX_GET_ACTIVITY, &activity);   if (activity < jitter->activity_threshold)       jitter_buffer_update_delay(jitter->packets, &packet, NULL);    jitter_buffer_tick(jitter->packets);   return ourRet;}

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;}

uint16 SpeexPlugin::getDecodingSampleRate() const		throw(OperationNotPerfomedException) {	if (!decoder)		throw OperationNotPerfomedException("Decoder not initialized");	spx_int32_t sample;	speex_decoder_ctl(decoder->state, SPEEX_GET_SAMPLING_RATE, &sample);	return sample;}

static void decoder_config(void *st){	int ret;	ret = speex_decoder_ctl(st, SPEEX_SET_ENH, &sconf.enhancement);	if (ret) {		warning("speex: SPEEX_SET_ENH: %d/n", ret);	}}

	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 ];	}

EXPORT int speex_decode(void *state, SpeexBits *bits, float *out){   int i, ret;   spx_int32_t N;   spx_int16_t short_out[MAX_IN_SAMPLES];   speex_decoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);   ret = (*((SpeexMode**)state))->dec(state, bits, short_out);   for (i=0;i<N;i++)      out[i] = short_out[i];   return ret;}

void speex_jitter_init(SpeexJitter *jitter, void *decoder, int sampling_rate){   jitter->dec = decoder;   speex_decoder_ctl(decoder, SPEEX_GET_FRAME_SIZE, &jitter->frame_size);   jitter->packets = jitter_buffer_init(jitter->frame_size);   speex_bits_init(&jitter->current_packet);   jitter->valid_bits = 0;   jitter->activity_threshold = 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;}

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;}

void CASpeexDecoder::BDCReset(){    speex_bits_reset(&mSpeexBits);    if (mSpeexDecoderState != NULL)        speex_decoder_ctl(mSpeexDecoderState, SPEEX_RESET_STATE, NULL); //??!    mSpeexFPList.clear();    mNumFrames = 0;    mOutBufferUsedSize = 0;    mOutBufferStart = 0;    XCACodec::BDCReset();}

void CASpeexDecoder::BDCUninitialize(){    speex_bits_destroy(&mSpeexBits);    if (mSpeexDecoderState != NULL)        speex_decoder_ctl(mSpeexDecoderState, SPEEX_RESET_STATE, NULL); //??!    mSpeexFPList.clear();    if (mOutBuffer)        delete[] mOutBuffer;    mOutBuffer = NULL;    mOutBufferSize = 0;    mOutBufferUsedSize = 0;    mOutBufferStart = 0;    XCACodec::BDCUninitialize();}

//*****************************************************************************////! This function returns the current frame size from the decoder.//!//! This function queries the decoder for the current decode frame size in byte//! and returns it to the caller.//!//! /return The current decoder frame size.////*****************************************************************************int32_tSpeexDecodeFrameSizeGet(void){    int iFrameSize;    //    // Return 0 if the wrong request is made.    //    iFrameSize = 0;    //    // Query the decoder for the current frame size.    //    speex_decoder_ctl(g_sSpeexDecoder.pvState, SPEEX_GET_FRAME_SIZE,                      &iFrameSize);    return(iFrameSize);}

/* * Modify codec settings. */static pj_status_t  spx_codec_modify(pjmedia_codec *codec, 				     const pjmedia_codec_param *attr ){    struct spx_private *spx;    int tmp;    spx = (struct spx_private*) codec->codec_data;    /* VAD */    tmp = (attr->setting.vad != 0);    speex_encoder_ctl(spx->enc, SPEEX_SET_VAD, &tmp);    speex_encoder_ctl(spx->enc, SPEEX_SET_DTX, &tmp);    /* PENH */    tmp = attr->setting.penh;    speex_decoder_ctl(spx->dec, SPEEX_SET_ENH, &tmp);    return PJ_SUCCESS;}