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();
}
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;
}
//*****************************************************************************
//
//! 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_t
SpeexDecodeInit(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);
}
void SpeexPlugin::buildDecoder(std::string modeName)
throw(OperationNotPerfomedException) {
if (decoder)
throw OperationNotPerfomedException("The decoder already exists. "
"Please call endDecoder before perform this task");
SpeexMode mode = getMode(modeName);
if (mode == INVALID_MODE)
throw OperationNotPerfomedException("Invalid Mode");
decoder = new HalfCodec;
decoder->mode = mode;
speex_bits_init(&decoder->bits);
switch (mode) {
case MODE_NB:
decoder->state = speex_decoder_init(&speex_nb_mode);
break;
case MODE_WB:
decoder->state = speex_decoder_init(&speex_wb_mode);
break;
case MODE_UWB:
decoder->state = speex_decoder_init(&speex_uwb_mode);
break;
};
}
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;
}
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 ];
}
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;
}
