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;
}
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;
}
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();
}
}
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 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;
}
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);
}
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 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 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);
}
}
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;
}
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);
}
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 ];
}
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;
}
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);
}
static int encode_update(struct auenc_state **aesp, const struct aucodec *ac,
struct auenc_param *prm, const char *fmtp)
{
struct auenc_state *st;
int ret, err = 0;
if (!aesp || !ac || !prm)
return EINVAL;
if (prm->ptime != SPEEX_PTIME)
return EPROTO;
if (*aesp)
return 0;
st = mem_zalloc(sizeof(*st), encode_destructor);
if (!st)
return ENOMEM;
st->frame_size = ac->srate * SPEEX_PTIME / 1000;
st->channels = ac->ch;
/* Encoder */
st->enc = speex_encoder_init(resolve_mode(ac->srate));
if (!st->enc) {
err = ENOMEM;
goto out;
}
speex_bits_init(&st->bits);
encoder_config(st->enc);
ret = speex_encoder_ctl(st->enc, SPEEX_GET_FRAME_SIZE,
&st->frame_size);
if (ret) {
warning("speex: SPEEX_GET_FRAME_SIZE: %d\n", ret);
}
if (str_isset(fmtp)) {
struct pl params;
pl_set_str(¶ms, fmtp);
fmt_param_apply(¶ms, param_handler, st);
}
out:
if (err)
mem_deref(st);
else
*aesp = st;
return err;
}
/* initialize the speex library */
static void speexout_tilde_speex_init(t_speexout *x)
{
speex_bits_init(&x->x_bits);
switch ( x->x_mode )
{
case SPEEX_NB_MODE :
x->x_encstate = speex_encoder_init(&speex_nb_mode);
break;
case SPEEX_WB_MODE :
x->x_encstate = speex_encoder_init(&speex_wb_mode);
break;
default :
error( "speexout~ : severe error : encoding scheme is unknown" );
break;
}
speex_encoder_ctl(x->x_encstate, SPEEX_GET_FRAME_SIZE, (void*)&x->x_framesize);
post( "speexout~ : frame size : %d", x->x_framesize );
}
int main(int argc, char **argv)
{
char *inFile;
FILE *fin;
short in[FRAME_SIZE];
float input[FRAME_SIZE];
char cbits[200];
int nbBytes;
/*保存编码的状态*/
void *state;
/*保存字节因此他们可以被speex常规读写*/
SpeexBits bits;
int i, tmp;
//新建一个新的编码状态在窄宽(narrowband)模式下
state = speex_encoder_init(&speex_nb_mode);
//设置质量为8(15kbps)
tmp=8;
speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);
inFile = argv[1];
fin = fopen(inFile, "r");
//初始化结构使他们保存数据
speex_bits_init(&bits);
while (1) {
//读入一帧16bits的声音
fread(in, sizeof(short), FRAME_SIZE, fin);
if (feof(fin))
break;
//把16bits的值转化为float,以便speex库可以在上面工作
for (i=0;i<FRAME_SIZE;i++)
input[i]=in[i];
//清空这个结构体里所有的字节,以便我们可以编码一个新的帧
speex_bits_reset(&bits);
//对帧进行编码
speex_encode(state, input, &bits);
//把bits拷贝到一个利用写出的char型数组
nbBytes = speex_bits_write(&bits, cbits, 200);
//首先写出帧的大小,这是sampledec文件需要的一个值,但是你的应用程序中可能不一样
fwrite(&nbBytes, sizeof(int), 1, stdout);
//写出压缩后的数组
fwrite(cbits, 1, nbBytes, stdout);
}
//释放编码器状态量
speex_encoder_destroy(state);
//释放bit_packing结构
speex_bits_destroy(&bits);
fclose(fin);
return 0;
}
NetworkSoundRecorder::NetworkSoundRecorder(State::Context* context)
: m_context(context)
, m_frameSize(160)
{
speex_bits_init(&m_speexBits);
m_speexState = speex_encoder_init(&speex_nb_mode);
int quality = 6;
speex_encoder_ctl(m_speexState, SPEEX_SET_QUALITY, &quality);
int enabled = 1;
int target = 16000;
m_speexPreprocessState = speex_preprocess_state_init(m_frameSize, 8180);
speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC, &enabled);
speex_preprocess_ctl(m_speexPreprocessState, SPEEX_PREPROCESS_SET_AGC_TARGET, &target);
setProcessingInterval(cpp3ds::milliseconds(100));
}
/*
* Get codec bitrate and frame size.
*/
static pj_status_t get_speex_info( struct speex_param *p )
{
void *state;
int tmp;
/* Create temporary encoder */
state = speex_encoder_init(p->mode);
if (!state)
return PJMEDIA_CODEC_EFAILED;
/* Set the quality */
if (p->quality != -1)
speex_encoder_ctl(state, SPEEX_SET_QUALITY, &p->quality);
/* Sampling rate. */
speex_encoder_ctl(state, SPEEX_SET_SAMPLING_RATE, &p->clock_rate);
/* VAD off to have max bitrate */
tmp = 0;
speex_encoder_ctl(state, SPEEX_SET_VAD, &tmp);
/* Complexity. */
if (p->complexity != -1)
speex_encoder_ctl(state, SPEEX_SET_COMPLEXITY, &p->complexity);
/* Now get the frame size */
speex_encoder_ctl(state, SPEEX_GET_FRAME_SIZE, &p->samples_per_frame);
/* Now get the average bitrate */
speex_encoder_ctl(state, SPEEX_GET_BITRATE, &p->bitrate);
/* Calculate framesize. */
p->framesize = p->bitrate * 20 / 1000;
/* Now get the maximum bitrate by using maximum quality (=10) */
tmp = 10;
speex_encoder_ctl(state, SPEEX_SET_QUALITY, &tmp);
speex_encoder_ctl(state, SPEEX_GET_BITRATE, &p->max_bitrate);
/* Destroy encoder. */
speex_encoder_destroy(state);
return PJ_SUCCESS;
}
void AudioInput::setMaxBandwidth(int bytespersec) {
int audiorate;
int baserate;
void *es;
es = speex_encoder_init(speex_lib_get_mode(SPEEX_MODEID_WB));
float f = static_cast<float>(g.s.iQuality);
do {
speex_encoder_ctl(es, SPEEX_SET_VBR_QUALITY, &f);
speex_encoder_ctl(es, SPEEX_GET_BITRATE, &baserate);
audiorate = baserate;
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;
if (f <= 1.9)
break;
if (audiorate > bytespersec) {
f -= 1.0f;
}
} while (audiorate > bytespersec);
speex_encoder_destroy(es);
speex_encoder_ctl(esEncState, SPEEX_SET_VBR_QUALITY, &f);
speex_encoder_ctl(esEncState, SPEEX_SET_VBR_MAX_BITRATE, &baserate);
g.iAudioBandwidth = audiorate;
g.iAudioQuality = lroundf(f);
}
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
}
//*****************************************************************************
//
//! Initialize the encoder's state to prepare for encoding new frames.
//!
//! \param iSampleRate is the sample rate of the incoming audio.
//! \param iComplexity is the complexity setting for the encoder.
//! \param iQuality is the quality setting for the encoder.
//!
//! This function will initializes the encoder by setting the sample rate,
//! complexity and quality settings. The \e iComplexity and \e iQuality
//! settings are explained further in the Speex documentation.
//!
//! \return This function returns 0.
//
//*****************************************************************************
int32_t
SpeexEncodeInit(int iSampleRate, int iComplexity, int iQuality)
{
const SpeexMode *psMode;
//
// Clear out the flags for this instance.
//
g_sSpeexEncoder.ui32Flags = 0;
//
// Read out the current encoder mode.
//
psMode = speex_lib_get_mode(SPEEX_MODEID_NB);
//
// Create a new decoder state in narrow band mode.
//
g_sSpeexEncoder.pvState = speex_encoder_init(psMode);
//
// Initialize the bit stream.
//
speex_bits_init(&g_sSpeexEncoder.sBits);
//
// Set the quality.
//
SpeexEncodeQualitySet(iQuality);
//
// Set the complexity and sample rate for the encoder.
//
speex_encoder_ctl(g_sSpeexEncoder.pvState, SPEEX_SET_COMPLEXITY,
&iComplexity);
speex_encoder_ctl(g_sSpeexEncoder.pvState, SPEEX_SET_SAMPLING_RATE,
&iSampleRate);
return(0);
}
