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