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