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; }
void *ph_speex_enc_init(SpeexMode *mode) { struct speexenc *speex; int tmp; speex = (struct speexenc*) calloc(sizeof(struct speexenc), 1); if (!speex) { return 0; } speex->st = speex_encoder_init(mode); tmp=0; speex_encoder_ctl(speex->st, SPEEX_SET_VBR, &tmp); tmp=8; speex_encoder_ctl(speex->st, SPEEX_SET_QUALITY, &tmp); tmp=1; speex_encoder_ctl(speex->st, SPEEX_SET_COMPLEXITY, &tmp); speex_bits_init(&speex->bits); return speex; }
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_t SpeexEncodeQualitySet(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 ]; }