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

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

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

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

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

bool NetworkSoundRecorder::onStart(){	int sampleRate = getSampleRate();	speex_encoder_ctl(m_speexState, SPEEX_SET_SAMPLING_RATE, &sampleRate);	speex_encoder_ctl(m_speexState, SPEEX_GET_FRAME_SIZE, &m_frameSize);	m_samples.clear();	return true;}

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

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

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

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

void RakVoice::SetEncoderParameter(void* enc_state, int vartype, int val){	if (enc_state){ 		// Set parameter for just one encoder		int ret = speex_encoder_ctl(enc_state, vartype, &val);		RakAssert(ret==0);			} else {		// Set parameter for all encoders		for (unsigned int index=0; index < voiceChannels.Size(); index++)		{			int ret = speex_encoder_ctl(voiceChannels[index]->enc_state, vartype, &val);			RakAssert(ret==0);		}	}}

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

int speex_std_high_mode_request_handler(SpeexBits *bits, void *state, void *data){   int m;   m = speex_bits_unpack_unsigned(bits, 4);   speex_encoder_ctl(data, SPEEX_SET_HIGH_MODE, &m);   return 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;}

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 speex_std_vbr_quality_request_handler(SpeexBits *bits, void *state, void *data){   int qual;   qual = speex_bits_unpack_unsigned(bits, 4);   speex_encoder_ctl(data, SPEEX_SET_VBR_QUALITY, &qual);   return 0;}

EXPORT int speex_std_low_mode_request_handler(SpeexBits *bits, void *state, void *data){   spx_int32_t m;   m = speex_bits_unpack_unsigned(bits, 4);   speex_encoder_ctl(data, SPEEX_SET_LOW_MODE, &m);   return 0;}

int speex_std_vbr_request_handler(SpeexBits *bits, void *state, void *data){   int vbr;   vbr = speex_bits_unpack_unsigned(bits, 1);   speex_encoder_ctl(data, SPEEX_SET_VBR, &vbr);   return 0;}

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

uint16 SpeexPlugin::getEncodingSampleRate() const		throw(OperationNotPerfomedException) {	if (!encoder)		throw OperationNotPerfomedException("Encoder not initialized");	spx_int32_t sample;	speex_encoder_ctl(encoder->state, SPEEX_GET_SAMPLING_RATE, &sample);	return sample;}

void SpeexEncoder::SetQuality(int qualityIn){	fprintf(stderr, "SpeexEncoder: SetQuality %i /n", qualityIn);	quality = qualityIn;	if (quality >= 0)	{		speex_encoder_ctl(st, SPEEX_SET_QUALITY, &quality);	}}

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

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

//*****************************************************************************////! This function sets the current quality setting for the Speex encoder.//!//! /param iQuality is the new Quality setting to use for the Speex encoder.//!//! This function will use the /e iQuality setting as the new quality setting//! for the Speex encoder.//!//! /return This function returns 0.////*****************************************************************************int32_tSpeexEncodeQualitySet(int iQuality){    //    // Set the current encoder quality setting.    //    speex_encoder_ctl(g_sSpeexEncoder.pvState, SPEEX_SET_QUALITY, &iQuality);    return(0);}

EXPORT int speex_encode_int(void *state, spx_int16_t *in, SpeexBits *bits){   int i;   spx_int32_t N;   float float_in[MAX_IN_SAMPLES];   speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &N);   for (i=0;i<N;i++)      float_in[i] = in[i];   return (*((SpeexMode**)state))->enc(state, float_in, bits);}

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

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

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