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;
}
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;
};
}
void gviSpursSpeexDecoderInitialize(SpursSpeexTaskOutput *spuTaskOut)
{
void * decoder = gviSpursSpeexStateBuffer;
int perceptualEnhancement = 1;
// create a new decoder state
if (gviSpursSpeexTaskDesc.mSamplesPerSecond == GVRate_8KHz)
speex_decoder_init(&speex_nb_mode, decoder);
else if (gviSpursSpeexTaskDesc.mSamplesPerSecond == GVRate_16KHz)
speex_decoder_init(&speex_wb_mode, decoder);
else
{
//spuDebugPrintf("[Speex][SPU] Error: invalid sample rate!\n");
spuTaskOut->mSpeexReturnCode = -1;
}
if(!decoder)
{
//spuDebugPrintf("[Speex][SPU] Error: initializing decoder failed!\n");
spuTaskOut->mSpeexReturnCode = -2;
}
// turn on the perceptual enhancement
speex_decoder_ctl(decoder, SPEEX_SET_ENH, &perceptualEnhancement);
spuTaskOut->mSpeexReturnCode = 0;
}
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
}
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;
}
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);
}
}
//*****************************************************************************
//
//! 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);
}
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;
}
static void dec_preprocess(MSFilter *f){
DecState *s=(DecState*)f->data;
const SpeexMode *mode=NULL;
int modeid;
switch(s->rate){
case 8000:
modeid = SPEEX_MODEID_NB; /* rate = 8000Hz */
break;
case 16000:
modeid = SPEEX_MODEID_WB; /* rate = 16000Hz */
break;
/* should be supported in the future */
case 32000:
modeid = SPEEX_MODEID_UWB; /* rate = 32000Hz */
break;
default:
ms_error("Unsupported rate for speex decoder (back to default rate=8000).");
modeid=SPEEX_MODEID_NB;
}
/* warning: speex_lib_get_mode() is not available on speex<1.1.12 */
mode = speex_lib_get_mode(modeid);
s->state=speex_decoder_init(mode);
speex_mode_query(mode,SPEEX_MODE_FRAME_SIZE,&s->frsz);
if (s->penh==1)
speex_decoder_ctl (s->state, SPEEX_SET_ENH, &s->penh);
s->sample_time=0;
}
void *ph_speex_dec_init(SpeexMode *mode)
{
struct speexdec *speex;
int tmp;
speex = (struct speexdec *)calloc(sizeof(struct speexdec), 1);
if (!speex)
{
return 0;
}
speex->st = speex_decoder_init(mode);
tmp=0;
speex_decoder_ctl(speex->st, SPEEX_SET_VBR, &tmp);
tmp=8;
speex_decoder_ctl(speex->st, SPEEX_SET_QUALITY, &tmp);
tmp=1;
speex_decoder_ctl(speex->st, SPEEX_SET_COMPLEXITY, &tmp);
speex_bits_init(&speex->bits);
return speex;
}
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 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;
}
/*
* 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;
}
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;
}
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 ];
}
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);
}
}
int tdav_codec_speex_open(tmedia_codec_t* self)
{
static int quality = SPEEX_DEFAULT_QUALITY;
tdav_codec_speex_t* speex = (tdav_codec_speex_t*)self;
switch(speex->type){
case tdav_codec_speex_type_nb:
speex->encoder.state = speex_encoder_init(&speex_nb_mode);
speex->decoder.state = speex_decoder_init(&speex_nb_mode);
break;
case tdav_codec_speex_type_wb:
speex->encoder.state = speex_encoder_init(&speex_wb_mode);
speex->decoder.state = speex_decoder_init(&speex_wb_mode);
break;
case tdav_codec_speex_type_uwb:
speex->encoder.state = speex_encoder_init(&speex_uwb_mode);
speex->decoder.state = speex_decoder_init(&speex_uwb_mode);
break;
default:
TSK_DEBUG_ERROR("Not implemented");
return -2;
}
speex_decoder_ctl(speex->decoder.state, SPEEX_GET_FRAME_SIZE, &speex->decoder.size);
speex->decoder.size *= sizeof(spx_int16_t);
if(!(speex->decoder.buffer = tsk_calloc(speex->decoder.size, 1))){
speex->decoder.size = speex->decoder.size = 0;
TSK_DEBUG_ERROR("Failed to allocate new buffer");
return -3;
}
speex_encoder_ctl(speex->encoder.state, SPEEX_SET_QUALITY, &quality);
speex_encoder_ctl(speex->encoder.state, SPEEX_GET_FRAME_SIZE, &speex->encoder.size);
speex_bits_init(&speex->encoder.bits);
speex_bits_init(&speex->decoder.bits);
speex_bits_reset(&speex->encoder.bits);
speex_bits_reset(&speex->decoder.bits);
return 0;
}
static int decode_update(struct audec_state **adsp,
const struct aucodec *ac, const char *fmtp)
{
struct audec_state *st;
int err = 0;
(void)fmtp;
if (!adsp || !ac)
return EINVAL;
if (*adsp)
return 0;
st = mem_zalloc(sizeof(*st), decode_destructor);
if (!st)
return ENOMEM;
st->frame_size = ac->srate * SPEEX_PTIME / 1000;
st->channels = ac->ch;
/* Decoder */
st->dec = speex_decoder_init(resolve_mode(ac->srate));
if (!st->dec) {
err = ENOMEM;
goto out;
}
speex_bits_init(&st->bits);
if (2 == st->channels) {
/* Stereo. */
st->stereo.balance = 1;
st->stereo.e_ratio = .5f;
st->stereo.smooth_left = 1;
st->stereo.smooth_right = 1;
st->callback.callback_id = SPEEX_INBAND_STEREO;
st->callback.func = speex_std_stereo_request_handler;
st->callback.data = &st->stereo;
speex_decoder_ctl(st->dec, SPEEX_SET_HANDLER,
&st->callback);
}
decoder_config(st->dec);
out:
if (err)
mem_deref(st);
else
*adsp = st;
return err;
}
static void *process_header (struct spx_data *data)
{
void *st;
const SpeexMode *mode;
int modeID;
SpeexCallback callback;
int enhance = ENHANCE_AUDIO;
data->header = speex_packet_to_header ((char*)data->op.packet,
data->op.bytes);
if (!data->header) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open speex file: can't read header");
return NULL;
}
if (data->header->mode >= SPEEX_NB_MODES) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open speex file: Mode number %"PRId32
" does not exist in this version",
data->header->mode);
return NULL;
}
modeID = data->header->mode;
mode = speex_mode_list[modeID];
if (mode->bitstream_version < data->header->mode_bitstream_version) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open speex file: The file was encoded "
"with a newer version of Speex.");
return NULL;
}
if (mode->bitstream_version > data->header->mode_bitstream_version) {
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open speex file: The file was encoded "
"with an older version of Speex.");
return NULL;
}
st = speex_decoder_init (mode);
speex_decoder_ctl(st, SPEEX_SET_ENH, &enhance);
speex_decoder_ctl(st, SPEEX_GET_FRAME_SIZE, &data->frame_size);
callback.callback_id = SPEEX_INBAND_STEREO;
callback.func = speex_std_stereo_request_handler;
callback.data = &data->stereo;
speex_decoder_ctl(st, SPEEX_SET_HANDLER, &callback);
speex_decoder_ctl(st, SPEEX_SET_SAMPLING_RATE, &data->header->rate);
return st;
}
GVBool gviSpeexNewDecoder(GVDecoderData * data)
{
void * decoder;
int perceptualEnhancement = 1;
// create a new decoder state
if (gviGetSampleRate() == GVRate_8KHz)
decoder = speex_decoder_init(&speex_nb_mode);
else if (gviGetSampleRate() == GVRate_16KHz)
decoder = speex_decoder_init(&speex_wb_mode);
else
return GVFalse;
if(!decoder)
return GVFalse;
// turn on the perceptual enhancement
speex_decoder_ctl(decoder, SPEEX_SET_ENH, &perceptualEnhancement);
*data = decoder;
return GVTrue;
}
void ms_speex_dec_init_core(MSSpeexDec *obj,const SpeexMode *mode)
{
int pf=1;
obj->speex_state=speex_decoder_init(mode);
speex_bits_init(&obj->bits);
/* enable the perceptual post filter */
speex_decoder_ctl(obj->speex_state,SPEEX_SET_PF, &pf);
speex_mode_query(mode, SPEEX_MODE_FRAME_SIZE, &obj->frame_size);
obj->initialized=1;
}
static int speex_decoder_construct(struct ast_trans_pvt *pvt, const SpeexMode *profile)
{
struct speex_coder_pvt *tmp = pvt->pvt;
if (!(tmp->speex = speex_decoder_init(profile)))
return -1;
speex_bits_init(&tmp->bits);
speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
if (enhancement)
speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);
return 0;
}
static int speextolin_new(struct ast_trans_pvt *pvt)
{
struct speex_coder_pvt *tmp = pvt->pvt;
if (!(tmp->speex = speex_decoder_init(&speex_nb_mode)))
return -1;
speex_bits_init(&tmp->bits);
speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
if (enhancement)
speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);
return 0;
}
NS_IMETHODIMP
otSpeexDecoder::SourceSet(otISource *source)
{
nsresult rv;
PRUint32 sampleRate;
PRUint16 ptime;
if (!source) {
if (mTarget)
mTarget->SourceSet(nsnull);
FreeData();
return NS_OK;
}
rv = source->GetCodecInfo(getter_AddRefs(mCodecInfo));
if (NS_FAILED(rv))
return rv;
rv = mCodecInfo->GetClockrate(&sampleRate);
if (NS_FAILED(rv))
return rv;
rv = mCodecInfo->GetPtime(&ptime);
if (NS_FAILED(rv))
return rv;
mFrameSize = 2*ptime*sampleRate/1000;
mSpeexState = speex_decoder_init(sampleRate == 8000 ? &speex_nb_mode :
sampleRate == 16000 ? &speex_wb_mode :
&speex_uwb_mode);
if (!mSpeexState) {
FreeData();
return NS_ERROR_OUT_OF_MEMORY;
}
mSpeexBits = new SpeexBits();
if (!mSpeexBits) {
FreeData();
return NS_ERROR_OUT_OF_MEMORY;
}
speex_bits_init(mSpeexBits);
return NS_OK;
}
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;
}
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;
}
static ErlDrvData codec_drv_start(ErlDrvPort port, char *buff)
{
int tmp;
codec_data* d = (codec_data*)driver_alloc(sizeof(codec_data));
d->port = port;
speex_bits_init(&d->bits);
/* FIXME hardcoded narrowband mode (speex_wb_mode, speex_uwb_mode) */
d->estate = speex_encoder_init(&speex_nb_mode);
d->dstate = speex_decoder_init(&speex_nb_mode);
// tmp=8;
// speex_encoder_ctl(d->estate, SPEEX_SET_QUALITY, &tmp);
tmp=3;
speex_encoder_ctl(d->estate, SPEEX_SET_COMPLEXITY, &tmp);
// tmp=8000;
// speex_encoder_ctl(d->estate, SPEEX_SET_SAMPLING_RATE, &tmp);
tmp=1;
speex_decoder_ctl(d->dstate, SPEEX_SET_ENH, &tmp);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
return (ErlDrvData)d;
}
//function sets up the encoder/decoder structs and buffers, returns required samples/frame
int setup_codecs(){
//Init the state structs in narrowband (8 kHz) mode
enc_state = speex_encoder_init(&speex_wb_mode);
dec_state = speex_decoder_init(&speex_wb_mode);
//Set the quality to 8 (28 kbps)
int tmp=QUALITY;
speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);
//enable the perceptual enhancer (reduce noise)
tmp = 1;
speex_decoder_ctl(dec_state, SPEEX_SET_ENH, &tmp);
//Init the buffers
speex_bits_init(&enc_bits);
speex_bits_init(&dec_bits);
//get the frame size needed for specified settings
speex_encoder_ctl(enc_state,SPEEX_GET_FRAME_SIZE,&tmp);
return tmp; //return the frame size
}
AudioOutputSpeech::AudioOutputSpeech(boost::shared_ptr<ClientUser> user, MessageHandler::UDPMessageType type) : AudioOutputUser(user->qsName) {
int err;
p = user;
umtType = type;
unsigned int srate = 0;
cCodec = NULL;
cdDecoder = NULL;
if (umtType != MessageHandler::UDPVoiceSpeex) {
srate = SAMPLE_RATE;
iFrameSize = srate / 100;
dsSpeex = NULL;
} else {
speex_bits_init(&sbBits);
dsSpeex = speex_decoder_init(speex_lib_get_mode(SPEEX_MODEID_UWB));
int iArg=1;
speex_decoder_ctl(dsSpeex, SPEEX_SET_ENH, &iArg);
speex_decoder_ctl(dsSpeex, SPEEX_GET_FRAME_SIZE, &iFrameSize);
speex_decoder_ctl(dsSpeex, SPEEX_GET_SAMPLING_RATE, &srate);
}
if (srate != SAMPLE_RATE)
srs = speex_resampler_init(1, srate, SAMPLE_RATE, 3, &err);
else
srs = NULL;
iOutputSize = static_cast<unsigned int>(ceilf(static_cast<float>(iFrameSize * SAMPLE_RATE) / static_cast<float>(SAMPLE_RATE)));
iBufferOffset = iBufferFilled = iLastConsume = 0;
bLastAlive = true;
iMissCount = 0;
iMissedFrames = 0;
ucFlags = 0xFF;
jbJitter = jitter_buffer_init(iFrameSize);
int margin = g.s.iJitterBufferSize * iFrameSize;
jitter_buffer_ctl(jbJitter, JITTER_BUFFER_SET_MARGIN, &margin);
fFadeIn = new float[iFrameSize];
fFadeOut = new float[iFrameSize];
float mul = static_cast<float>(M_PI / (2.0 * static_cast<double>(iFrameSize)));
for (unsigned int i=0;i<iFrameSize;++i)
fFadeIn[i] = fFadeOut[iFrameSize-i-1] = sinf(static_cast<float>(i) * mul);
}
