自学教程：C++ speex_encoder_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;}

GVBool gviSpeexInitialize(int quality, GVRate sampleRate){	int rate;	int bitsPerFrame;	int samplesPerSecond;		// we shouldn't already be initialized	if(gviSpeexInitialized)		return GVFalse;	// create a new encoder state	if (sampleRate == GVRate_8KHz)		gviSpeexEncoderState = speex_encoder_init(&speex_nb_mode);	else if (sampleRate == GVRate_16KHz)		gviSpeexEncoderState = speex_encoder_init(&speex_wb_mode);	else		return GVFalse;	if(!gviSpeexEncoderState)		return GVFalse;	// set the sampling rate	samplesPerSecond = sampleRate;	speex_encoder_ctl(gviSpeexEncoderState, SPEEX_SET_SAMPLING_RATE, &samplesPerSecond);	// Get the samples per frame setting.	speex_encoder_ctl(gviSpeexEncoderState, SPEEX_GET_FRAME_SIZE, &gviSpeexSamplesPerFrame);	// set the quality	speex_encoder_ctl(gviSpeexEncoderState, SPEEX_SET_QUALITY, &quality);	// initialize the bits struct	speex_bits_init(&gviSpeexBits);	// get the bitrate	speex_encoder_ctl(gviSpeexEncoderState, SPEEX_GET_BITRATE, &rate);	// convert to bits per frame	bitsPerFrame = (rate / (sampleRate / gviSpeexSamplesPerFrame));	// convert to bytes per frame and store, round up to allocate more space than needed.	gviSpeexEncodedFrameSize = (bitsPerFrame / 8);	if (bitsPerFrame % 8)		gviSpeexEncodedFrameSize++;	// create our encoding and decoding buffer.	gviSpeexBuffer = (float *)gsimalloc(gviSpeexSamplesPerFrame * sizeof(float));	// we're now initialized	gviSpeexInitialized = GVTrue;	return GVTrue;}

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 Transmitter::setup(int srate, int quality, int abr, int vbr, float vbr_quality, int complexity, int vad, int dtx, int txstop){	if (recording)	{		recorder->end();		stop();	}	SpeexMode *mode = NULL;		switch (srate)	{		case 32000:			mode = (SpeexMode *) &speex_uwb_mode;			speexmode = DRTA_INFO_MODE_ULTRAWIDE;			break;		case 16000:			mode = (SpeexMode *) &speex_wb_mode;			speexmode = DRTA_INFO_MODE_WIDE;			break;		case 8000:			mode = (SpeexMode *) &speex_nb_mode;			speexmode = DRTA_INFO_MODE_NARROW;			break;	}		if (state)		speex_encoder_destroy(state);		state = speex_encoder_init(mode);	speex_encoder_ctl(state, SPEEX_SET_SAMPLING_RATE, &srate);	speex_encoder_ctl(state, SPEEX_SET_COMPLEXITY, &complexity);	if (vbr)	{		speex_encoder_ctl(state, SPEEX_SET_VBR, &vbr);		speex_encoder_ctl(state, SPEEX_SET_VBR_QUALITY, &vbr_quality);	}	else	{		speex_encoder_ctl(state, SPEEX_SET_QUALITY, &quality);		speex_encoder_ctl(state, SPEEX_SET_VAD, &vad);	}	if (abr)		speex_encoder_ctl(state, SPEEX_SET_ABR, &abr);	speex_encoder_ctl(state, SPEEX_SET_DTX, &dtx);	speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &frame_size);		stoptx = (int) ((srate / frame_size)*txstop);		speex_bits_init(&bits);		rate = srate;	if (recording)	{		initRecorder();		go();	}}

int  spx_encode_init(){    fp_speex_send = fopen("speex_send.spx" ,"w+");    if(fp_speex_send == NULL){         printf("open sdcard/fp_speex_send.spx file failed");    }    speex_encode_union_t * speex_encode_u = (speex_encode_union_t *)malloc(sizeof(speex_encode_union_t));    if(speex_encode_u == NULL){        printf("speex_encode_union malloc failed .../n");        exit(1);    }        /*Create a new encoder state in narrowband mode*/   speex_encode_u->state = speex_encoder_init(&speex_nb_mode);    /*Set the quality to 8 (15 kbps)*/    int tmp = 8;    speex_encoder_ctl(speex_encode_u->state, SPEEX_SET_QUALITY, &tmp);    /*Initialization of the structure that holds the bits*/    speex_bits_init(&speex_encode_u->bits);    return (int )speex_encode_u;}

static void speex_init_encoder (enix_aenc_t *this_gen, enix_stream_t *stream) {    speex_t          *this = (speex_t *) this_gen;  int                bitrate, channels, sample_rate;  enix_options_t    *options;  int                ret;  /*    * gather parameters   */  options      = this->encoder.options;  bitrate      = options->get_num_option (options, "bitrate");  channels     = stream->get_property (stream, ENIX_STREAM_PROP_AUDIO_CHANNELS);  sample_rate  = stream->get_property (stream, ENIX_STREAM_PROP_SAMPLE_RATE);  printf ("acodec_speex: %d audio channels, %d samples/sec/n",	  channels, sample_rate);  /*   * speex init   */  speex_bits_init (&this->bits);  this->enc_state = speex_encoder_init (&speex_nb_mode);     speex_encoder_ctl (this->enc_state, SPEEX_GET_FRAME_SIZE, &this->frame_size);  printf ("acodec_speex: codec init done. frame size is %d/n", this->frame_size);  this->num_samples = 0;}

void SpeexPlugin::buildEncoder(std::string modeName)		throw(OperationNotPerfomedException) {	if (encoder)		throw OperationNotPerfomedException("The encoder already exists. "			"Please call endEncoder before perform this task");	SpeexMode mode = getMode(modeName);	const ::SpeexMode *_mode = 0;	switch (mode) {	case MODE_NB:		_mode = &speex_nb_mode;		break;	case MODE_WB:		_mode = &speex_wb_mode;		break;	case MODE_UWB:		_mode = &speex_uwb_mode;		break;	default:		throw OperationNotPerfomedException("Invalid Mode");	};	encoder = new HalfCodec;	encoder->mode = mode;	speex_bits_init(&encoder->bits);	encoder->state = speex_encoder_init(_mode);}

int AudioInput::getMaxBandwidth() {	int audiorate;	void *es;	float f = static_cast<float>(g.s.iQuality);	es = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));	speex_encoder_ctl(es,SPEEX_SET_VBR_QUALITY, &f);	speex_encoder_ctl(es,SPEEX_GET_BITRATE,&audiorate);	speex_encoder_destroy(es);	audiorate /= 400/g.s.iFramesPerPacket;	// Overhead	audiorate += 20 + 8 + 4 + 3 + 1 + 2;	if (g.s.bTransmitPosition)		audiorate += 12;	if (NetworkConfig::TcpModeEnabled())		audiorate += 12;	audiorate = (audiorate * 50) / g.s.iFramesPerPacket;	return audiorate;}

void Phone::setup(int mode, int quality, int abr, int vbr, float vbr_quality, int complexity, int vad, int dtx, int txstop, int th, int ring_vol){	bool restart = recording;	if (restart)		stopRecorder();	if (enc_state)		speex_encoder_destroy(enc_state);	SpeexMode *spmode = NULL;		switch (mode)	{		case IHU_NARROW:			spmode = (SpeexMode *) &speex_nb_mode;			break;		case IHU_WIDE:			spmode = (SpeexMode *) &speex_wb_mode;			break;		case IHU_ULTRAWIDE:			spmode = (SpeexMode *) &speex_uwb_mode;			break;	}		enc_state = speex_encoder_init(spmode);	speex_encoder_ctl(enc_state, SPEEX_SET_COMPLEXITY, &complexity);	if (vbr)	{		speex_encoder_ctl(enc_state, SPEEX_SET_VBR, &vbr);		speex_encoder_ctl(enc_state, SPEEX_SET_VBR_QUALITY, &vbr_quality);	}	else	{		speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &quality);		speex_encoder_ctl(enc_state, SPEEX_SET_VAD, &vad);	}	if (abr)		speex_encoder_ctl(enc_state, SPEEX_SET_ABR, &abr);	speex_encoder_ctl(enc_state, SPEEX_SET_DTX, &dtx);		speex_encoder_ctl(enc_state, SPEEX_GET_SAMPLING_RATE, &rate);	speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &frame_size);	stoptx = txstop;		speex_bits_init(&enc_bits);		ring_vol = -ring_vol + 1;	float vol = 0.0;	if (ring_vol <= 0)		vol = powf(VOL_FACTOR, (float) (ring_vol));	for (int i=0; i<SIZE_RING_32; i++)		ringBuffer[i] = ((float) ring_32[i]) * vol;	setThreshold(th);	if (restart)		startRecorder();}

void init_speex_encoder() {    if (!gEncoderState) {        gEncoderState = speex_encoder_init(&speex_nb_mode);	int quality = 3; // 8000 bps        speex_encoder_ctl(gEncoderState, SPEEX_SET_QUALITY, &quality);	int complexity = 4; // net play is demanding, ok?        speex_encoder_ctl(gEncoderState, SPEEX_SET_COMPLEXITY, &complexity);        int tmp = kNetworkAudioSampleRate;        speex_encoder_ctl(gEncoderState, SPEEX_SET_SAMPLING_RATE, &tmp);        speex_bits_init(&gEncoderBits);	// set up the preprocessor	int frame_size;	speex_encoder_ctl(gEncoderState, SPEEX_GET_FRAME_SIZE, &frame_size);	gPreprocessState = speex_preprocess_state_init(frame_size, kNetworkAudioSampleRate);	// turn on AGC and denoise	tmp = 1;	speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_DENOISE, &tmp);	tmp = 1;	speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_AGC, &tmp);		float agc_level = 32768.0 * 0.7;	speex_preprocess_ctl(gPreprocessState, SPEEX_PREPROCESS_SET_AGC_LEVEL, &agc_level);    }    }

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

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

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

void SpeexEncoder::encoder_init(){	int quality = 5;	modeID = SPEEX_MODEID_NB;	mode = speex_lib_get_mode(modeID);	encoder_state = speex_encoder_init(mode);	speex_encoder_ctl(encoder_state, SPEEX_SET_QUALITY, &quality);	speex_bits_init(&encoder_bits);}

JNIEXPORT void JNICALL FUNCSPEEX(initEncode)(JNIEnv* env, jobject obj, jint compression) {	speex_bits_init(&ebits);	enc_state = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_NB));	speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &compression);	speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &enc_frame_size);	int tmp = 1;	speex_encoder_ctl(enc_state, SPEEX_SET_COMPLEXITY, &tmp);	tmp = 0;	speex_encoder_ctl(enc_state, SPEEX_SET_VBR, &tmp);}

	pcm2speex_int()	{		state = speex_encoder_init(&speex_nb_mode); 		int quality = QUALITY ; 		speex_encoder_ctl(state, SPEEX_SET_QUALITY, &quality); 		speex_bits_init(&bits);		speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &frame_size);		in  = new short[ frame_size ];	}

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

void createEncoder(void){	signed int tmp = 0;	speex_bits_init(&inbits);	pEnc = speex_encoder_init(&speex_nb_mode);	//tmp=0;	//speex_encoder_ctl(pEnc, SPEEX_SET_VBR, &tmp);	tmp=4;	speex_encoder_ctl(pEnc, SPEEX_SET_QUALITY, &tmp);	tmp=2;	speex_encoder_ctl(pEnc, SPEEX_SET_COMPLEXITY, &tmp);}

static int encode_update(struct auenc_state **aesp, const struct aucodec *ac,			 struct auenc_param *prm, const char *fmtp){	struct auenc_state *st;	int ret, err = 0;	if (!aesp || !ac || !prm)		return EINVAL;	if (prm->ptime != SPEEX_PTIME)		return EPROTO;	if (*aesp)		return 0;	st = mem_zalloc(sizeof(*st), encode_destructor);	if (!st)		return ENOMEM;	st->frame_size = ac->srate * SPEEX_PTIME / 1000;	st->channels = ac->ch;	/* Encoder */	st->enc = speex_encoder_init(resolve_mode(ac->srate));	if (!st->enc) {		err = ENOMEM;		goto out;	}	speex_bits_init(&st->bits);	encoder_config(st->enc);	ret = speex_encoder_ctl(st->enc, SPEEX_GET_FRAME_SIZE,				&st->frame_size);	if (ret) {		warning("speex: SPEEX_GET_FRAME_SIZE: %d/n", ret);	}	if (str_isset(fmtp)) {		struct pl params;		pl_set_str(&params, fmtp);		fmt_param_apply(&params, param_handler, st);	} out:	if (err)		mem_deref(st);	else		*aesp = st;	return err;}

    /* initialize the speex library */static void speexout_tilde_speex_init(t_speexout *x){    speex_bits_init(&x->x_bits);    switch ( x->x_mode )     {      case SPEEX_NB_MODE :        x->x_encstate = speex_encoder_init(&speex_nb_mode);        break;      case SPEEX_WB_MODE :        x->x_encstate = speex_encoder_init(&speex_wb_mode);        break;        default :        error( "speexout~ : severe error : encoding scheme is unknown" );        break;    }    speex_encoder_ctl(x->x_encstate, SPEEX_GET_FRAME_SIZE, (void*)&x->x_framesize);    post( "speexout~ : frame size : %d", x->x_framesize );}

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

NetworkSoundRecorder::NetworkSoundRecorder(State::Context* context): m_context(context), m_frameSize(160){	speex_bits_init(&m_speexBits);	m_speexState = speex_encoder_init(&speex_nb_mode);	int quality = 6;	speex_encoder_ctl(m_speexState, SPEEX_SET_QUALITY, &quality);	int enabled = 1;	int target = 16000;	m_speexPreprocessState = speex_preprocess_state_init(m_frameSize, 8180);	speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC, &enabled);	speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC_TARGET, &target);	setProcessingInterval(cpp3ds::milliseconds(100));}

/* * Get codec bitrate and frame size. */static pj_status_t get_speex_info( struct speex_param *p ){    void *state;    int tmp;    /* Create temporary encoder */    state = speex_encoder_init(p->mode);    if (!state)	return PJMEDIA_CODEC_EFAILED;    /* Set the quality */    if (p->quality != -1)	speex_encoder_ctl(state, SPEEX_SET_QUALITY, &p->quality);    /* Sampling rate. */    speex_encoder_ctl(state, SPEEX_SET_SAMPLING_RATE, &p->clock_rate);    /* VAD off to have max bitrate */    tmp = 0;    speex_encoder_ctl(state, SPEEX_SET_VAD, &tmp);    /* Complexity. */    if (p->complexity != -1)	speex_encoder_ctl(state, SPEEX_SET_COMPLEXITY, &p->complexity);    /* Now get the frame size */    speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &p->samples_per_frame);    /* Now get the average bitrate */    speex_encoder_ctl(state, SPEEX_GET_BITRATE, &p->bitrate);    /* Calculate framesize. */    p->framesize = p->bitrate * 20 / 1000;    /* Now get the maximum bitrate by using maximum quality (=10) */    tmp = 10;    speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);    speex_encoder_ctl(state, SPEEX_GET_BITRATE, &p->max_bitrate);    /* Destroy encoder. */    speex_encoder_destroy(state);    return PJ_SUCCESS;}

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}

//*****************************************************************************////! Initialize the encoder's state to prepare for encoding new frames.//!//! /param iSampleRate is the sample rate of the incoming audio.//! /param iComplexity is the complexity setting for the encoder.//! /param iQuality is the quality setting for the encoder.//!//! This function will initializes the encoder by setting the sample rate,//! complexity and quality settings.  The /e iComplexity and /e iQuality//! settings are explained further in the Speex documentation.//!//! /return This function returns 0.////*****************************************************************************int32_tSpeexEncodeInit(int iSampleRate, int iComplexity, int iQuality){    const SpeexMode *psMode;    //    // Clear out the flags for this instance.    //    g_sSpeexEncoder.ui32Flags = 0;    //    // Read out the current encoder mode.    //    psMode = speex_lib_get_mode(SPEEX_MODEID_NB);    //    // Create a new decoder state in narrow band mode.    //    g_sSpeexEncoder.pvState = speex_encoder_init(psMode);    //    // Initialize the bit stream.    //    speex_bits_init(&g_sSpeexEncoder.sBits);    //    // Set the quality.    //    SpeexEncodeQualitySet(iQuality);    //    // Set the complexity and sample rate for the encoder.    //    speex_encoder_ctl(g_sSpeexEncoder.pvState, SPEEX_SET_COMPLEXITY,                      &iComplexity);    speex_encoder_ctl(g_sSpeexEncoder.pvState, SPEEX_SET_SAMPLING_RATE,                      &iSampleRate);    return(0);}