JNIEXPORT jint JNICALL Java_org_thoughtcrime_redphone_codec_SpeexCodec_decode (JNIEnv *env, jobject obj, jbyteArray encArr, jshortArray decArr, jint encLen ){
cenv = env;
if( !initialized ) {
logv(env, "tried to decode without initializing" );
return -1;
}
if (decArr == NULL) {
logv(env, "Speex decode passed a null decode buffer" );
return -1;
}
jint dec_buffer_len = env->GetArrayLength( decArr );
int dec_buffer_idx = 0;
jbyte *jb_enc_stream;
char *enc_stream;
SpeexBits *dbits = NULL; //if this is null, speex will do PLC for us
if( !env->IsSameObject( encArr, NULL ) ) {
jb_enc_stream = env->GetByteArrayElements( encArr, NULL );
enc_stream = (char *)jb_enc_stream;
speex_bits_read_from( &dec_bits, enc_stream, encLen );
env->ReleaseByteArrayElements( encArr, jb_enc_stream, JNI_ABORT );
dbits = &dec_bits;
} else {
// logv( env, "null encArr" );
}
while( 0 == speex_decode_int( dec, dbits, dec_buffer+dec_buffer_idx ) ) {
dec_buffer_idx += dec_frame_size;
if( dec_buffer_idx + dec_frame_size >= dec_buffer_len ) {
logv( env, "out of space in the decArr buffer, idx=%d", dec_buffer_idx );
break;
}
if( dec_buffer_idx + dec_frame_size >= dec_frame_size * MAX_DEC_FRAMES ) {
logv( env, "out of space in the dec_buffer buffer, idx=%d", dec_buffer_idx );
break;
}
if( dbits == NULL ) {
// logv(env, "did PLC" );
break;//only generate one frame for PLC...
}
}
env->SetShortArrayRegion( decArr, 0, dec_buffer_idx, dec_buffer );
return dec_buffer_idx;
}
void ms_speex_dec_process(MSSpeexDec *obj)
{
MSFifo *outf=obj->outf[0];
MSQueue *inq=obj->inq[0];
gint16 *output;
gint gran=obj->frame_size*2;
gint i;
MSMessage *m;
g_return_if_fail(inq!=NULL);
g_return_if_fail(outf!=NULL);
m=ms_queue_get(inq);
g_return_if_fail(m!=NULL);
speex_bits_reset(&obj->bits);
ms_fifo_get_write_ptr(outf,gran,(void**)&output);
g_return_if_fail(output!=NULL);
if (m->data!=NULL){
speex_bits_read_from(&obj->bits,m->data,m->size);
/* decode */
speex_decode_int(obj->speex_state,&obj->bits,(short*)output);
}else{
/* we have a missing packet */
speex_decode_int(obj->speex_state,NULL,(short*)output);
}
ms_message_destroy(m);
}
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);
}
}
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 int libspeex_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
LibSpeexContext *s = avctx->priv_data;
int16_t *output = data, *end;
int i, num_samples;
num_samples = s->frame_size * avctx->channels;
end = output + *data_size / sizeof(*output);
speex_bits_read_from(&s->bits, buf, buf_size);
for (i = 0; speex_bits_remaining(&s->bits) && output + num_samples < end; i++) {
int ret = speex_decode_int(s->dec_state, &s->bits, output);
if (ret <= -2) {
av_log(avctx, AV_LOG_ERROR, "Error decoding Speex frame.\n");
return -1;
} else if (ret == -1)
// end of stream
break;
if (avctx->channels == 2)
speex_decode_stereo_int(output, s->frame_size, &s->stereo);
output += num_samples;
}
avctx->frame_size = s->frame_size * i;
*data_size = avctx->channels * avctx->frame_size * sizeof(*output);
return buf_size;
}
int voice_play(const char *buf, int length, int codec)
{
if (length <= 0)
return 0;
if (codec == EKG_CODEC_SPEEX) {
#if HAVE_SPEEX
spx_int16_t speex_output[320];
speex_bits_read_from(&speex_dec_bits, buf, length);
speex_decode_int(voice_speex_dec, &speex_dec_bits, speex_output); /* XXX, != 0 return? */
if (write(voice_fd, speex_output, sizeof(speex_output)) != sizeof(speex_output))
return -1;
return 0;
#else
printf("voice_play() received speex packet, but HAVE_SPEEX\n");
return -1;
#endif
}
if (codec == EKG_CODEC_GSM) {
#if HAVE_GSM
const int ramki_dwie = 33 + 33;
gsm_signal gsm_output[160];
const char *pos = buf;
while (pos <= (buf + length - ramki_dwie)) {
switch (codec) {
case EKG_CODEC_GSM:
if (gsm_decode(voice_gsm_dec, (unsigned char *) pos, gsm_output)) return -1;
pos += 33;
break;
}
if (write(voice_fd, gsm_output, 320) != 320)
return -1;
switch (codec) {
case EKG_CODEC_GSM:
if (gsm_decode(voice_gsm_dec, (unsigned char *) pos, gsm_output)) return -1;
pos += 33;
break;
}
if (write(voice_fd, gsm_output, 320) != 320)
return -1;
}
return 0;
#else
printf("voice_play() received gsm packet, but HAVE_GSM\n");
return -1;
#endif
}
return -1;
}
signed short* decodeSPEEX(BYTE *data)
{
speex_bits_read_from(&obits, (char*)data, SPEEX_SIZE);
speex_decode_int(pDec, &obits, out_short);
speex_bits_reset(&obits);
return (signed short*)(&out_short[0]);
}
/*****************************************************************************
* DecodePacket: decodes a Speex packet.
*****************************************************************************/
static block_t *DecodePacket( decoder_t *p_dec, ogg_packet *p_oggpacket )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_oggpacket->bytes )
{
/* Copy Ogg packet to Speex bitstream */
speex_bits_read_from( &p_sys->bits, (char *)p_oggpacket->packet,
p_oggpacket->bytes );
p_sys->i_frame_in_packet = 0;
}
/* Decode one frame at a time */
if( p_sys->i_frame_in_packet < p_sys->p_header->frames_per_packet )
{
block_t *p_aout_buffer;
if( p_sys->p_header->frame_size == 0 )
return NULL;
p_aout_buffer =
decoder_NewAudioBuffer( p_dec, p_sys->p_header->frame_size );
if( !p_aout_buffer )
{
return NULL;
}
switch( speex_decode_int( p_sys->p_state, &p_sys->bits,
(int16_t *)p_aout_buffer->p_buffer ) )
{
case -2:
msg_Err( p_dec, "decoding error: corrupted stream?" );
case -1: /* End of stream */
return NULL;
}
if( speex_bits_remaining( &p_sys->bits ) < 0 )
{
msg_Err( p_dec, "decoding overflow: corrupted stream?" );
}
if( p_sys->p_header->nb_channels == 2 )
speex_decode_stereo_int( (int16_t *)p_aout_buffer->p_buffer,
p_sys->p_header->frame_size,
&p_sys->stereo );
/* Date management */
p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
p_aout_buffer->i_length =
date_Increment( &p_sys->end_date, p_sys->p_header->frame_size )
- p_aout_buffer->i_pts;
p_sys->i_frame_in_packet++;
return p_aout_buffer;
}
else
{
return NULL;
}
}
int Speex_2_Pcm16( unsigned char* out_buf, unsigned char* in_buf,
unsigned int size,
unsigned int channels, unsigned int rate, long h_codec )
{
SpeexState* ss;
short* pcm = (short*) out_buf;
int frames_out = 0;
ss = (SpeexState*) h_codec;
if (!ss || channels!=1)
return -1;
speex_bits_read_from(&ss->decoder.bits, (char*)in_buf, size);
/* We don't know where frame boundaries are,
but the minimum frame size is 43 */
while (speex_bits_remaining(&ss->decoder.bits)>40) {
int ret;
ret = speex_decode_int(ss->decoder.state, &ss->decoder.bits, pcm);
pcm+= ss->frame_size;
if (ret==-2) {
ERROR("while calling speex_decode\n");
return -1;
}
if (ret==-1) break;
frames_out++;
}
return frames_out*ss->frame_size*sizeof(short);
}
// renyang - 替音訊解碼
void Call::decodeAudioData(char *buf, int len)
{
#ifdef REN_DEBUG
qWarning("Call::decodeAudioData()");
#endif
if (dec_state)
{
// renyang - Initializes the bit-stream from the data in an area of memory
// renyang - 把一連串的buf轉到bit-stream
speex_bits_read_from(&bits, buf, len);
// renyang - 把bits解碼到outBuffer(為float型態)
// renyang - 當<0表示解碼失敗
if (speex_decode(dec_state, &bits, outBuffer) < 0)
{
emit warning("Warning: wrong decryption key or stream corrupted!");
disableDecrypt();
}
else
{
// renyang - 來到這裡表示解碼成功
// renyang - 把解碼之後的音訊(outBuffer)放到soundBuffer中
putData(outBuffer, frame_size);
}
}
}
int speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *current_timestamp, void** userData)
{
int i;
int jbRet; /* results returned by the JB */
int ourRet; /* result that we will return */
spx_int32_t activity;
char data[2048];
JitterBufferPacket packet;
packet.data = data;
packet.len = 2048; /* AAAAARGH: it took a week to find and add this missing line */
if (jitter->valid_bits)
{
/* Try decoding last received packet */
jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (jbRet == 0)
{
jitter_buffer_tick(jitter->packets);
return 1;
} else {
jitter->valid_bits = 0;
}
}
jbRet = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, NULL);
if (jbRet != JITTER_BUFFER_OK)
{
/* no packet found, so no corresponding user-data */
*userData = NULL;
/* No packet found... extrapolate one */
/*fprintf (stderr, "lost/late frame\n");*/
/*Packet is late or lost*/
speex_decode_int(jitter->dec, NULL, out);
ourRet = 2;
} else {
/* found a packet, so there is corresponding user-data */
*userData = (void*)(packet.user_data);
speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
/* Decode packet */
jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (jbRet == 0) {
ourRet = 0;
jitter->valid_bits = 1;
} else {
/* Error while decoding */
ourRet = 3;
for (i=0;i<jitter->frame_size;i++) out[i]=0;
}
}
speex_decoder_ctl(jitter->dec, SPEEX_GET_ACTIVITY, &activity);
if (activity < jitter->activity_threshold)
jitter_buffer_update_delay(jitter->packets, &packet, NULL);
jitter_buffer_tick(jitter->packets);
return ourRet;
}
static switch_status_t switch_speex_decode(switch_codec_t *codec,
switch_codec_t *other_codec,
void *encoded_data,
uint32_t encoded_data_len,
uint32_t encoded_rate, void *decoded_data, uint32_t *decoded_data_len, uint32_t *decoded_rate,
unsigned int *flag)
{
struct speex_context *context = codec->private_info;
short *buf;
if (!context) {
return SWITCH_STATUS_FALSE;
}
buf = decoded_data;
if (*flag & SWITCH_CODEC_FLAG_SILENCE) {
speex_decode_int(context->decoder_state, NULL, buf);
} else {
speex_bits_read_from(&context->decoder_bits, (char *) encoded_data, (int) encoded_data_len);
speex_decode_int(context->decoder_state, &context->decoder_bits, buf);
}
*decoded_data_len = codec->implementation->decoded_bytes_per_packet;
return SWITCH_STATUS_SUCCESS;
}
static int decode_audio(sh_audio_t *sh, unsigned char *buf,
int minlen, int maxlen) {
double pts;
context_t *ctx = sh->context;
int len, framelen, framesamples;
char *packet;
int i, err;
speex_decoder_ctl(ctx->dec_context, SPEEX_GET_FRAME_SIZE, &framesamples);
framelen = framesamples * ctx->hdr->nb_channels * sizeof(short);
if (maxlen < ctx->hdr->frames_per_packet * framelen) {
mp_msg(MSGT_DECAUDIO, MSGL_V, "maxlen too small in decode_audio\n");
return -1;
}
len = ds_get_packet_pts(sh->ds, (unsigned char **)&packet, &pts);
if (len <= 0) return -1;
if (sh->pts == MP_NOPTS_VALUE)
sh->pts = 0;
if (pts != MP_NOPTS_VALUE) {
sh->pts = pts;
sh->pts_bytes = 0;
}
speex_bits_read_from(&ctx->bits, packet, len);
i = ctx->hdr->frames_per_packet;
do {
err = speex_decode_int(ctx->dec_context, &ctx->bits, (short *)buf);
if (err == -2)
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Error decoding file.\n");
if (ctx->hdr->nb_channels == 2)
speex_decode_stereo_int((short *)buf, framesamples, &ctx->stereo);
buf = &buf[framelen];
} while (--i > 0);
sh->pts_bytes += ctx->hdr->frames_per_packet * framelen;
return ctx->hdr->frames_per_packet * framelen;
}
int qSpeexDecode(QSpeexCodecPtr handle, void* inputBytes, int inputSize, void* outputSamples, int outputSize)
{
int offset, remaining;
short *out = (short*)outputSamples;
/* If there is no input to read, we certainly can't read it. */
if (inputBytes != NULL) {
speex_bits_read_from(&handle->decBits, inputBytes, inputSize);
}
for (offset=0; offset<outputSize; offset+=handle->frameSize) {
if (inputBytes != NULL) {
if (!speex_bits_remaining(&handle->decBits)) {
// Ran out of input data
return 2;
}
speex_decode_int(handle->decState, &handle->decBits, out+offset);
}
else {
/* Extrapolate output-buffer based on current decoder state. */
speex_decode_int(handle->decState, NULL, out+offset);
}
}
remaining = speex_bits_remaining(&handle->decBits);
if (remaining >= 8) {
/* If less than a byte is left over, that's OK. */
fprintf(stderr, "qSpeexDecode(): %d bits left over\n", remaining);
return 1; // Still have encoded bits left over
}
else return 0; // A-OK!!
}
/*! \brief convert and store into outbuf */
static int speextolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct speex_coder_pvt *tmp = pvt->pvt;
/* Assuming there's space left, decode into the current buffer at
the tail location. Read in as many frames as there are */
int x;
int res;
int16_t *dst = pvt->outbuf.i16;
/* XXX fout is a temporary buffer, may have different types */
#ifdef _SPEEX_TYPES_H
spx_int16_t fout[1024];
#else
float fout[1024];
#endif
if (f->datalen == 0) { /* Native PLC interpolation */
if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
#ifdef _SPEEX_TYPES_H
speex_decode_int(tmp->speex, NULL, dst + pvt->samples);
#else
speex_decode(tmp->speex, NULL, fout);
for (x=0;x<tmp->framesize;x++) {
dst[pvt->samples + x] = (int16_t)fout[x];
}
#endif
pvt->samples += tmp->framesize;
pvt->datalen += 2 * tmp->framesize; /* 2 bytes/sample */
return 0;
}
/* Read in bits */
speex_bits_read_from(&tmp->bits, f->data.ptr, f->datalen);
for (;;) {
#ifdef _SPEEX_TYPES_H
res = speex_decode_int(tmp->speex, &tmp->bits, fout);
#else
res = speex_decode(tmp->speex, &tmp->bits, fout);
#endif
if (res < 0)
break;
if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
for (x = 0 ; x < tmp->framesize; x++)
dst[pvt->samples + x] = (int16_t)fout[x];
pvt->samples += tmp->framesize;
pvt->datalen += 2 * tmp->framesize; /* 2 bytes/sample */
}
return 0;
}
int ph_speexwb_decode(void *ctx, const void *src, int srcsize, void *dst, int dstsize)
{
int i;
struct speexdec *speex = (struct speexdec *)ctx;
speex_bits_read_from(&speex->bits, src, srcsize);
speex_decode_int(speex->st, &speex->bits, dst);
speex_bits_reset(&speex->bits);
return SPEEX_WB_FRAME_SAMPLES*2;
}
JNIEXPORT jint JNICALL Java_com_speex_Speex_decode(JNIEnv *env,
jobject obj, jbyteArray encoded, jshortArray lin, jint size) {
jbyte buffer[dec_frame_size];
jshort output_buffer[size];
jsize encoded_length = size;
int nsamples = (size - 1) / dec_frame_size + 1;
int i, offset = 0, tot_shorts = 0;
if (!codec_open)
return 0;
speex_bits_reset(&dbits);
// 把数据写入buffer
for(i = 0; i < nsamples; i++){
if(offset + i * dec_frame_size + dec_frame_size > size) {
env->GetByteArrayRegion(encoded, offset + i * dec_frame_size,
size - (offset + i * dec_frame_size), buffer);
speex_bits_read_from(&dbits, (char *) buffer, size - (offset + i * dec_frame_size));
} else {
env->GetByteArrayRegion(encoded, offset + i * dec_frame_size,
dec_frame_size, buffer);
speex_bits_read_from(&dbits, (char *) buffer, dec_frame_size);
}
}
// env->GetByteArrayRegion(encoded, 0, encoded_length, buffer);
// // buffer数据写入dbits
// speex_bits_read_fdrom(&dbits, (char *) buffer, encoded_length);
// dbits数据写入output_buffer
speex_decode_int(dec_state, &dbits, output_buffer);
// TODO
env->SetShortArrayRegion(lin, 0, encoded_length, output_buffer);
/*env->SetShortArrayRegion(lin, 0, dec_frame_size, output_buffer);*/
/*return (jint) dec_frame_size;*/
/*return (jint) encoded_length;*/
return (jint) encoded_length;
}
Boolean CASpeexDecoder::GenerateFrames()
{
Boolean ret = true;
int result;
mBDCStatus = kBDCStatusOK;
SpeexFramePacket &sfp = mSpeexFPList.front();
speex_bits_read_from(&mSpeexBits, reinterpret_cast<char*> (mBDCBuffer.GetData()), sfp.bytes);
if (sfp.frames > 0 && (sfp.frames - mSpeexHeader.frame_size * mSpeexHeader.frames_per_packet > 0)) {
UInt32 zeroBytes = mOutputFormat.FramesToBytes(sfp.frames - mSpeexHeader.frame_size * mSpeexHeader.frames_per_packet);
memset(mOutBuffer + mOutBufferUsedSize, 0, zeroBytes);
mOutBufferUsedSize += zeroBytes;
}
for (SInt32 i = 0; i < mSpeexHeader.frames_per_packet; i++) {
if (mOutputFormat.mFormatFlags & kAudioFormatFlagsNativeFloatPacked != 0)
result = speex_decode(mSpeexDecoderState, &mSpeexBits, reinterpret_cast<float*> (mOutBuffer + mOutBufferUsedSize));
else
result = speex_decode_int(mSpeexDecoderState, &mSpeexBits, reinterpret_cast<spx_int16_t*> (mOutBuffer + mOutBufferUsedSize));
if (result < 0) {
mBDCStatus = kBDCStatusAbort;
return false;
}
if (mSpeexHeader.nb_channels == 2) {
if (mOutputFormat.mFormatFlags & kAudioFormatFlagsNativeFloatPacked != 0)
speex_decode_stereo(reinterpret_cast<float*> (mOutBuffer + mOutBufferUsedSize), mSpeexHeader.frame_size, &mSpeexStereoState);
else
speex_decode_stereo_int(reinterpret_cast<spx_int16_t*> (mOutBuffer + mOutBufferUsedSize), mSpeexHeader.frame_size, &mSpeexStereoState);
}
mOutBufferUsedSize += mOutputFormat.FramesToBytes(mSpeexHeader.frame_size);
}
if (sfp.frames == 0) {
mNumFrames += mSpeexHeader.frame_size * mSpeexHeader.frames_per_packet;
} else if (sfp.frames > 0) {
mNumFrames += sfp.frames;
if (mSpeexHeader.frame_size * mSpeexHeader.frames_per_packet - sfp.frames != 0)
mOutBufferStart += mOutputFormat.FramesToBytes(mSpeexHeader.frame_size * mSpeexHeader.frames_per_packet - sfp.frames);
} else {
mNumFrames -= sfp.frames;
}
mBDCBuffer.Zap(sfp.bytes);
mSpeexFPList.erase(mSpeexFPList.begin());
return ret;
}
void *os_sound_start_thread(void *_ca)
{
jcall_t *ca = (jcall_t*)_ca;
char data_in[160];
short sp_data_in_s[640];
float sp_data_in_f[640];
int have_more;
int timestamp = 0;
int i;
while (ca->enable_audio != -1)
{
memset(data_in, 0, 160);
/* receive ONE packet */
i = rtp_session_recv_with_ts(ca->rtp_session, data_in, 160, timestamp, &have_more);
speex_bits_reset(&ca->dec_speex_bits);
speex_bits_read_from(&ca->dec_speex_bits, data_in, i);
while(1)
{
int k;
k = speex_decode(ca->speex_dec, &ca->dec_speex_bits, sp_data_in_f);
if (k==-2)
{
exit(0);
}
else if (k==-1)
{
break;
}
else if (k==0)
{
int j;
for (j=0;j<ca->speex_fsize;j++)
{
if (sp_data_in_f[j]>32767)
sp_data_in_f[j]=32767;
if (sp_data_in_f[j]<-32767)
sp_data_in_f[j]=-32767;
sp_data_in_s[j] = (short) sp_data_in_f[j];
}
write(fd, sp_data_in_s, ca->speex_fsize);
}
}
timestamp += 160;
}
return NULL;
}
void gviSpeexDecodeSet(GVSample * out, const GVByte * in, GVDecoderData data)
{
int rcode;
int i;
// read the data into the bits
speex_bits_read_from(&gviSpeexBits, (char *)in, gviSpeexEncodedFrameSize);
// decode it
rcode = speex_decode((void *)data, &gviSpeexBits, gviSpeexBuffer);
GS_ASSERT(rcode == 0);
// convert the output from floats
for(i = 0 ; i < gviSpeexSamplesPerFrame ; i++)
out[i] = (GVSample)gviSpeexBuffer[i];
}
static int decode(struct audec_state *st, int16_t *sampv,
size_t *sampc, const uint8_t *buf, size_t len)
{
const size_t n = st->channels * st->frame_size;
size_t i = 0;
/* Read into bit-stream */
speex_bits_read_from(&st->bits, (char *)buf, (int)len);
/* Handle multiple Speex frames in one RTP packet */
while (speex_bits_remaining(&st->bits) >= MIN_FRAME_SIZE) {
int ret;
if (*sampc < n)
return ENOMEM;
ret = speex_decode_int(st->dec, &st->bits,
(int16_t *)&sampv[i]);
if (ret < 0) {
if (-1 == ret) {
}
else if (-2 == ret) {
warning("speex: decode: corrupt stream\n");
}
else {
warning("speex: decode: speex_decode_int:"
" ret=%d\n", ret);
}
break;
}
/* Transforms a mono frame into a stereo frame
using intensity stereo info */
if (2 == st->channels) {
speex_decode_stereo_int((int16_t *)&sampv[i],
st->frame_size,
&st->stereo);
}
i += n;
*sampc -= n;
}
*sampc = i;
return 0;
}
static int libspeex_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
LibSpeexContext *s = avctx->priv_data;
AVFrame *frame = data;
int16_t *output;
int ret, consumed = 0;
/* get output buffer */
frame->nb_samples = s->frame_size;
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
output = (int16_t *)frame->data[0];
/* if there is not enough data left for the smallest possible frame or the
next 5 bits are a terminator code, reset the libspeex buffer using the
current packet, otherwise ignore the current packet and keep decoding
frames from the libspeex buffer. */
if (speex_bits_remaining(&s->bits) < 5 ||
speex_bits_peek_unsigned(&s->bits, 5) == 0xF) {
/* check for flush packet */
if (!buf || !buf_size) {
*got_frame_ptr = 0;
return buf_size;
}
/* set new buffer */
speex_bits_read_from(&s->bits, buf, buf_size);
consumed = buf_size;
}
/* decode a single frame */
ret = speex_decode_int(s->dec_state, &s->bits, output);
if (ret <= -2) {
av_log(avctx, AV_LOG_ERROR, "Error decoding Speex frame.\n");
return AVERROR_INVALIDDATA;
}
if (avctx->channels == 2)
speex_decode_stereo_int(output, s->frame_size, &s->stereo);
*got_frame_ptr = 1;
return consumed;
}
NS_IMETHODIMP
otSpeexDecoder::AcceptData(const char* data, PRInt32 len)
{
DEBUG_DUMP1("otSpeexDecoder::AcceptData %d", len);
char buf[2048];
//memset(buf, 0, mFrameSize);
//return mTarget->AcceptData(data ? data : buf, data ? len : mFrameSize);
if (data) {
speex_bits_read_from(mSpeexBits, (char*)data, len);
speex_decode_int(mSpeexState, mSpeexBits, (spx_int16_t*)buf);
} else
speex_decode_int(mSpeexState, nsnull, (spx_int16_t*)buf);
return mTarget->AcceptData(buf, mFrameSize);
}
void gviSpursSpeexDecodeAdd(SpursSpeexTaskOutput *spuTaskOut)
{
char *inBuffer;
float *speexBuffer;
short *outBuffer;
int rcode;
unsigned int i;
//spuDebugPrintf("[Speex][SPU] allocating buffers for decoding\n");
speexBuffer = (float *)memalign(16, gviSpursSpeexTaskDesc.mOutputBufferSize * sizeof(float));
outBuffer = (short *)memalign(16, gviSpursSpeexTaskDesc.mOutputBufferSize * sizeof(short));
inBuffer = (char *)memalign(16, gviSpursSpeexTaskDesc.mInputBufferSize);
memset(speexBuffer, 0, gviSpursSpeexTaskDesc.mOutputBufferSize * sizeof(float));
memset(outBuffer, 0, gviSpursSpeexTaskDesc.mOutputBufferSize);
memset(inBuffer, 0, gviSpursSpeexTaskDesc.mInputBufferSize * sizeof(short));
//spuDebugPrintf("[Speex][SPU] done allocating, getting input data, inbuffer size: %d\n", gSpuSampleTaskDesc.mInputBufferSize);
cellDmaGet(inBuffer, (uint64_t)gviSpursSpeexTaskDesc.mInputBuffer, gviSpursSpeexTaskDesc.mInputBufferSize, DMA_TAG(1), 0,0);
cellDmaWaitTagStatusAll(DMA_MASK(1));
// spuDebugPrintf("[Speex][SPU] done getting input data, preparing for speex to decode\n");
// read the data into the bits
// (re)initialize the bits struct
speex_bits_init_buffer(&gviSpursSpeexBits,gviSpursSpeexBitsBuffer,sizeof(gviSpursSpeexBitsBuffer));
speex_bits_read_from(&gviSpursSpeexBits, (char *)inBuffer, gviSpursSpeexTaskDesc.mEncodedFrameSize);
// decode it
rcode = speex_decode((void *)gviSpursSpeexStateBuffer, &gviSpursSpeexBits, speexBuffer);
assert(rcode == 0);
//spuDebugPrintf("[Speex][SPU] done with speex decode\n");
// convert the output from floats
for(i = 0 ; i < gviSpursSpeexTaskDesc.mOutputBufferSize ; i++)
outBuffer[i] = (short)speexBuffer[i];
//spuDebugPrintf("[Speex][SPU] transferring data back\n");
cellDmaPut(outBuffer, (uint64_t)gviSpursSpeexTaskDesc.mOutputBuffer, gviSpursSpeexTaskDesc.mOutputBufferSize * sizeof(short), DMA_TAG(1), 0, 0);
cellDmaWaitTagStatusAll(DMA_MASK(1));
//spuDebugPrintf("[Speex][SPU] done transferring data back\n");
free(speexBuffer);
free(inBuffer);
free(outBuffer);
spuTaskOut->mSpeexReturnCode = 0;
}
void speex_jitter_get(SpeexJitter *jitter, short *out, int *current_timestamp)
{
int i;
int ret;
char data[2048];
JitterBufferPacket packet;
packet.data = data;
if (jitter->valid_bits)
{
/* Try decoding last received packet */
ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (ret == 0)
{
jitter_buffer_tick(jitter->packets);
return;
} else {
jitter->valid_bits = 0;
}
}
ret = jitter_buffer_get(jitter->packets, &packet, NULL);
if (ret != JITTER_BUFFER_OK)
{
/* No packet found */
/*fprintf (stderr, "lost/late frame\n");*/
/*Packet is late or lost*/
speex_decode_int(jitter->dec, NULL, out);
} else {
speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
/* Decode packet */
ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (ret == 0)
{
jitter->valid_bits = 1;
} else {
/* Error while decoding */
for (i=0;i<jitter->frame_size;i++)
out[i]=0;
}
}
jitter_buffer_tick(jitter->packets);
}
JNIEXPORT jint Java_com_speex_encode_Speex_decode
(JNIEnv *env, jobject obj, jbyteArray encoded, jshortArray lin, jint size) {
jbyte buffer[dec_frame_size];
jshort output_buffer[dec_frame_size];
jsize encoded_length = size;
if (!codec_open)
return 0;
env->GetByteArrayRegion(encoded, 0, encoded_length, buffer);
speex_bits_read_from(&dbits, (char *)buffer, encoded_length);
speex_decode_int(dec_state, &dbits, output_buffer);
env->SetShortArrayRegion(lin, 0, dec_frame_size,
output_buffer);
return (jint)dec_frame_size;
}
//*****************************************************************************
//
//! This function decodes a single frame of Speex encoded audio.
//!
//! /param pucInBuffer is the buffer that contains the Speex encoded audio.
//! /param ulInSize is the number of valid bytes in the pucInBuffer buffer.
//! /param pucOutBuffer is a pointer to the buffer to store decoded audio.
//! /param ulOutSize is the size of the buffer pointed to by the pucOutBuffer
//! pointer.
//!
//! This function will take a buffer of Speex encoded audio and decode it into
//! raw PCM audio. The /e pusInBuffer parameter should contain a single frame
//! encoded Speex audio. The /e pucOutBuffer will contain the decoded
//! audio after returning from this function.
//!
//! /return This function returns the number of decoded bytes in the
//! /e pucOutBuffer buffer.
//
//*****************************************************************************
int
SpeexDecode(unsigned char *pucInBuffer, unsigned long ulInSize,
unsigned char *pucOutBuffer, unsigned long ulOutSize)
{
int iBytes;
//
// Read in the bit stream to the Speex library.
//
speex_bits_read_from(&g_sSpeexDecoder.sBits, (char *)pucInBuffer, ulInSize);
//
// Decode one frame of data.
//
iBytes = speex_decode_int(g_sSpeexDecoder.State, &g_sSpeexDecoder.sBits,
(short *)pucOutBuffer);
return(iBytes);
}
void oper_one( const string& src, string& dst )
{
int block_size = dec_block_size( QUALITY, frame_size );
int src_len = src.size();
if( src_len % block_size != 0 )
{
return ;
}
int times = src_len / block_size ;
const char* buff = src.data() ;
for( int i = 0 ; i < times; ++ i )
{
speex_bits_read_from(&bits, (char*)(buff + i * block_size), block_size );
speex_decode_int(state, &bits, out);
dst.append( (char*)out, frame_size * sizeof(short) );
}
}
hsBool plSpeex::Decode(uint8_t *data, int size, int numFrames, int *numOutputBytes, short *out)
{
if(!fInitialized) return false;
*numOutputBytes = 0;
hsReadOnlyStream stream( size, data );
float *speexOutput = new float[fFrameSize]; // holds output from speex
short *pOut = out; // pointer to output short buffer
// create buffer for input data
uint8_t *frameData = new uint8_t[fFrameSize]; // holds the current frames data to be decoded
uint8_t frameLen; // holds the length of the current frame being decoded.
// Decode data
for (int i = 0; i < numFrames; i++)
{
stream.ReadLE( &frameLen ); // read the length of the current frame to be decoded
stream.Read( frameLen, frameData ); // read the data
memset(speexOutput, 0, fFrameSize * sizeof(float));
speex_bits_read_from(fBits, (char *)frameData, frameLen); // give data to speex
speex_decode(fDecoderState, fBits, speexOutput); // decode data
for(int j = 0; j < fFrameSize; j++)
{
pOut[j] = (short)(speexOutput[j]); // convert floats to shorts
}
pOut += fFrameSize;
}
delete[] frameData;
delete[] speexOutput;
*numOutputBytes = (numFrames * fFrameSize) * sizeof(short); // length of decoded voice data(out) in bytes
if(*numOutputBytes == 0)
return false;
return true;
}
//*****************************************************************************
//
//! This function decodes a single frame of Speex encoded audio.
//!
//! \param pui8InBuffer is the buffer that contains the Speex encoded audio.
//! \param ui32InSize is the number of valid bytes in the \e pui8InBuffer
//! buffer.
//! \param pui8OutBuffer is a pointer to the buffer to store decoded audio.
//! \param ui32OutSize is the size of the buffer pointed to by the
//! \e pui8OutBuffer pointer.
//!
//! This function will take a buffer of Speex encoded audio and decode it into
//! raw PCM audio. The \e pui16InBuffer parameter should contain a single
//! frame encoded Speex audio. The \e pui8OutBuffer will contain the decoded
//! audio after returning from this function.
//!
//! \return This function returns the number of decoded bytes in the
//! \e pui8OutBuffer buffer.
//
//*****************************************************************************
int32_t
SpeexDecode(uint8_t *pui8InBuffer, uint32_t ui32InSize, uint8_t *pui8OutBuffer,
uint32_t ui32OutSize)
{
int32_t i32Bytes;
//
// Read in the bit stream to the Speex library.
//
speex_bits_read_from(&g_sSpeexDecoder.sBits, (char *)pui8InBuffer,
ui32InSize);
//
// Decode one frame of data.
//
i32Bytes = speex_decode_int(g_sSpeexDecoder.pvState,
&g_sSpeexDecoder.sBits,
(int16_t *)pui8OutBuffer);
return(i32Bytes);
}
