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

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

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

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}

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

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

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

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

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

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

static struct spx_data *spx_open_internal (struct io_stream *stream){	struct spx_data *data;	SpeexStereoState stereo = SPEEX_STEREO_STATE_INIT;	data = (struct spx_data *)xmalloc (sizeof(struct spx_data));	decoder_error_init (&data->error);	data->stream = stream;	data->st = NULL;	data->stereo = stereo;	data->header = NULL;	data->output = NULL;	data->comment_packet = NULL;	data->bitrate = -1;	ogg_sync_init (&data->oy);	speex_bits_init (&data->bits);	if (!read_speex_header(data)) {		ogg_sync_clear (&data->oy);		speex_bits_destroy (&data->bits);		data->ok = 0;	}	else		data->ok = 1;	return data;}

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

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

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

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

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

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

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

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

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

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

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

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

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