uint16 t_g711u_audio_encoder::encode(int16 *sample_buf, uint16 nsamples,
uint8 *payload, uint16 payload_size, bool &silence)
{
assert(nsamples <= payload_size);
silence = false;
for (int i = 0; i < nsamples; i++) {
payload[i] = linear2ulaw(sample_buf[i]);
}
return nsamples;
}
int PCMUCodec::Encode (WORD *in,int inLen,BYTE* out,int outLen)
{
//Comprobamos las longitudes
if (outLen<inLen)
return 0;
//Y codificamos
for (int j = 0; j< inLen ;j++)
out[j]=linear2ulaw(in[j]);
return inLen;
}
NS_IMETHODIMP
otG711Encoder::AcceptData(const char* data, PRInt32 len)
{
DEBUG_DUMP1("otG711Encoder::AcceptData %d", len);
char frames[64*1024];
PRInt16 *buf = (PRInt16*)data;
for (int i = 0; i < len/2; i++)
frames[i] = (char)(mIsAlaw ? linear2alaw(buf[i]) : linear2ulaw(buf[i]));
return mTarget->AcceptData(frames, len/2);
}
int g711u_Encode( char *src, char *dest, int srclen, int *dstlen)
{
int i,tmp;
// signed short src_data;
// unsigned char mask;
unsigned short *ps=(unsigned short*)src;
static unsigned int data_type = 0xffffffff;
*dstlen=0;
tmp = srclen/2;
for(i=0; i<tmp; i++)
{
dest[i]=linear2ulaw(ps[i]);
}
*dstlen = srclen/2;
return 1;
}
//#define ECHO
thread basic_receive(ushort uart, ushort udp)
{
uint len = 0;
uchar buf[BUF_SIZE];
#ifdef ECHO
int i, j = 0;
uint value[5 * BUF_SIZE];
#endif
/* Enable all interrupts */
enable();
while (TRUE)
{
/* Read from the UDP device */
len = read(udp, buf, BUF_SIZE);
if (len > 0)
{
#ifdef ECHO
/* Echo audio effect */
for (i = 0; i < len; i++)
{
value[j] =
value[(j + BUF_SIZE) % (5 * BUF_SIZE)] * 4 / 5 +
ulaw2linear(buf[i]) / 64 + 512;
buf[i] = linear2ulaw((value[j] - 512) * 64);
j = (j + 1) % (5 * BUF_SIZE);
}
#endif
/* Write to the serial device */
write(uart, buf, len);
}
}
}
static int read_data_in(void *buffer, size_t num_sample, SP_FILE *sp){
SPIFR *spifr;
char *proc=" read_data_in " SPHERE_VERSION_STR;
int samples_read = 0;
int in_samples=0, o, oc, s, c, ret;
int block=0;
char *in_block=(char *)0, *out_block=(char *)0;
char *current_data_location = (char *)0;
char *out_conversion_block=(char *)0,*in_conversion_block=(char *)0;
char *next_out_block=(char *)0;
short *sh_data=(short *)0;
unsigned char *ulaw_data = (unsigned char *)0;
SP_CHECKSUM checksum=0, block_checksum=0;
int file_record_size;
char **arr_buff = (char **)0, *arr;
spifr = sp->read_spifr;
file_record_size = spifr->status->file_sample_n_bytes *
spifr->status->file_channel_count;
while ((samples_read < num_sample) &&
(! fob_feof(spifr->waveform->sp_fob))){
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Beginning block %d\n",proc,block);
/* read in either a block or the whole chunk if data */
if (spifr->waveform->file_data_buffer != CNULL) {
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: reading a block into temporary storage\n",
proc);
in_block = (void *)spifr->waveform->file_data_buffer;
current_data_location = in_block;
if ((in_samples = (num_sample - samples_read))>
TRANSLATION_LEN)
in_samples = TRANSLATION_LEN;
ret = fob_fread(in_block, file_record_size,
in_samples, spifr->waveform->sp_fob);
if (ret < 0)
return_err(proc,105,0,"Unable to read data");
} else {
/* there was no change in the sample coding so just read */
/* in the data */
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: read a block WITHOUT coding conversions\n",
proc);
ret = fob_fread(buffer, file_record_size,
num_sample, spifr->waveform->sp_fob);
if (ret < 0)
return_err(proc,107,0,"Unable to read data");
in_block = (void *)buffer;
current_data_location = in_block;
}
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: block read of %d Samples, expected %d\n",
proc,ret,num_sample);
in_samples = ret;
/**** ret is the number of samples per time period read in from */
/**** the file */
/**** Do the checksum computation before format changes occur ***/
switch (spifr->status->file_encoding){
case SP_se_pcm2:
/* DON'T SWAP if the coding type hasn't changed, and the */
/* output SBF == natural_sbf */
/* OR if the coding changed and the file SBF */
/* is == natural SBF */
if (((spifr->status->user_encoding == SP_se_pcm2) &&
(spifr->status->natural_sbf == spifr->status->user_sbf))
||
((spifr->status->user_encoding != SP_se_pcm2) &&
(spifr->status->natural_sbf == spifr->status->file_sbf))){
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: Not Swapping for checksum\n",proc);
checksum =
sp_compute_short_checksum((void *)in_block,in_samples*
spifr->status->file_channel_count,
FALSE);
} else {
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Swapping for checksum\n",proc);
checksum =
sp_compute_short_checksum((void *)in_block,
in_samples*spifr->status->file_channel_count, TRUE);
}
break;
default: {
int n;
n = in_samples * spifr->status->file_channel_count *
spifr->status->file_sample_n_bytes;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Computing char checksum %d bytes\n",
proc,n);
checksum = sp_compute_char_checksum(in_block, n);
break;
}
}
spifr->waveform->checksum =
sp_add_checksum(spifr->waveform->checksum,checksum);
block_checksum = checksum;
/*** FINISHED WITH THE CHECKSUMS ***/
samples_read += in_samples;
spifr->waveform->samples_read += in_samples;
if (sp_eof(sp))
/* only check this if the user_sample count is real */
/* Added June 22, 1994 by JGF */
if (spifr->status->user_sample_count != 999999999){
if (spifr->waveform->samples_read !=
spifr->status->user_sample_count){
spifr->waveform->read_premature_eof = TRUE;
return_err(proc,500,0,
rsprintf("Premature End-of-File %d read != %d",
spifr->waveform->samples_read,
spifr->status->user_sample_count));
}
}
if (spifr->waveform->samples_read ==
spifr->status->user_sample_count){
if ((! spifr->status->ignore_checksum) &&
(spifr->waveform->checksum !=
spifr->status->file_checksum)){
spifr->waveform->failed_checksum = TRUE;
return_err(proc,1000,0,
rsprintf("%sComputed %d != Expected %d",
"Checksum Test Failed ",
spifr->waveform->checksum,
spifr->status->file_checksum));
}
}
/**** Do the sample coding conversions ****/
if (((spifr->status->file_encoding == SP_se_ulaw) &&
(spifr->status->user_encoding == SP_se_pcm2)) ||
((spifr->status->file_encoding == SP_se_pcm2) &&
(spifr->status->user_encoding == SP_se_ulaw))) {
int samples_to_change =
in_samples*spifr->status->file_channel_count;
if ((spifr->status->channels != CHANNELSNULL) ||
(spifr->status->user_data_fmt == SP_df_array)){
out_conversion_block = next_out_block =
(char *)spifr->waveform->converted_buffer;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: using converted buffer output\n",
proc);
}
else {
out_conversion_block = (char *)buffer;
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: using buffer output argument\n",
proc);
if (next_out_block == (char *)0)
next_out_block = out_conversion_block;
}
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: converting %d (%d*%d) samples\n",proc,
samples_to_change,in_samples,
spifr->status->file_channel_count);
if ((spifr->status->file_encoding == SP_se_ulaw) &&
(spifr->status->user_encoding == SP_se_pcm2)) {
/* now convert the block into the buffer */
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Converting ULAW to PCM", proc);
/* set up some pointers */
ulaw_data =
(unsigned char *)spifr->waveform->file_data_buffer;
sh_data = (short *)next_out_block ;
/*** This was a bug, it used to compare to sp_sbf_10 ***/
if (spifr->status->user_sbf != get_natural_sbf(2)){
if (sp_verbose > 16)
fprintf(spfp," outputting 01 format bytes\n");
for (o=0; o < samples_to_change; o++) {
*sh_data = ulaw2linear_01_sbf_lut[*ulaw_data];
sh_data ++; ulaw_data ++;
}
} else {
if (sp_verbose > 16)
fprintf(spfp," outputting 10 format bytes\n");
for (o=0; o < samples_to_change; o++) {
*sh_data = ulaw2linear_10_sbf_lut[*ulaw_data];
sh_data ++; ulaw_data ++;
}
}
next_out_block = (char *)sh_data;
} else if ((spifr->status->file_encoding == SP_se_pcm2) &&
(spifr->status->user_encoding == SP_se_ulaw)) {
if (sp_verbose > 16)
fprintf(spfp,"Proc %s: Performing read translation%s\n",
proc," from PCM2 to ULAW");
/* set up some pointers */
sh_data = (short *)spifr->waveform->file_data_buffer;
ulaw_data = (unsigned char *)next_out_block;
if (spifr->status->file_sbf != spifr->status->natural_sbf){
char *p , temp; short odata;
if (sp_verbose > 16)
fprintf(spfp,
"Proc %s: Swapping input shorts\n", proc);
for (o=0; o < samples_to_change; o++) {
/* Pre swap the bytes */
odata = *sh_data;
p = (char *) &odata;
temp = *p;
*p = *(p + 1);
*(p + 1) = temp;
/* fprintf(spfp,
" %d -> %x -> %x\n",o,*sh_data,odata); */
*ulaw_data = linear2ulaw(odata);
sh_data ++; ulaw_data ++;
}
}else
for (o=0; o < samples_to_change; o++) {
*ulaw_data =linear2ulaw(*sh_data);
sh_data ++; ulaw_data ++;
}
next_out_block = (char *)ulaw_data;
} else
return_err(proc,109,0,"Internal Error");
current_data_location = out_conversion_block;
}
/* Do the channel conversions */
if (spifr->status->channels != CHANNELSNULL){
int in_recsize, out_recsize, in_chancnt, out_chancnt;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Converting channels\n",proc);
if (spifr->status->user_data_fmt == SP_df_array)
out_block = spifr->waveform->interleave_buffer;
else
if (out_block == (void *)0)
out_block = (void *)buffer;
current_data_location = out_block;
if (spifr->status->file_encoding != spifr->status->user_encoding)
in_conversion_block =
(void *)spifr->waveform->converted_buffer;
else
if (in_conversion_block == (void *)0)
in_conversion_block =
(void *)spifr->waveform->file_data_buffer;
in_chancnt = spifr->status->file_channel_count;
in_recsize = spifr->status->user_sample_n_bytes * in_chancnt;
out_chancnt = spifr->status->user_channel_count;
out_recsize = spifr->status->user_sample_n_bytes * out_chancnt;
for (oc=0; oc<spifr->status->channels->num_chan; oc++)
if (spifr->status->channels->ochan[oc].num_origin == 1){
char *in_ptr, *out_ptr;
in_ptr = in_conversion_block +
((spifr->status->channels->ochan[oc].orig_channel[0]-1)
* spifr->status->user_sample_n_bytes);
out_ptr = out_block +
(oc * spifr->status->user_sample_n_bytes);
for (s=0; s<in_samples; s++){
memcpy(out_ptr,in_ptr,
spifr->status->user_sample_n_bytes);
in_ptr += in_recsize;
out_ptr += out_recsize;
}
} else {
if (spifr->status->user_encoding == SP_se_pcm2) {
/* do a straight add */
ORIGINATION_CHAN *ochn;
short *in_ptr, *out_ptr;
int sum, ch;
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Adding PCM data %s %d\n",
proc, "channel",oc);
in_ptr = (short *)in_conversion_block;
out_ptr = (short *)out_block;
ochn = &(spifr->status->channels->ochan[oc]);
if (spifr->status->user_sbf== get_natural_sbf(2)){
for (s=0; s<in_samples; s++){
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
sum +=*(in_ptr+ochn->orig_channel[ch]-1);
}
if (sum > 32767) sum = 32767;
else if (sum < -32768) sum = -32768;
*(out_ptr + oc) = (short)sum;
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
} else {
short x;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: %s %d\n", proc,
"Adding Swapped PCM data channel",oc);
for (s=0; s<in_samples; s++){
/* fprintf(spfp,"sample %d\n",s); */
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
x = *(in_ptr+ochn->orig_channel[ch]-1);
swap_bytes(x);
sum += x;
/* fprintf(spfp," %d = %d\n",x,sum); */
}
if (sum > 32767) x = 32767;
else if (sum < -32768) x = -32768;
else x = sum;
swap_bytes(x);
*(out_ptr + oc) = (short)x;
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
}
} else if (spifr->status->user_encoding == SP_se_ulaw){
/* do an add on ulaw data */
ORIGINATION_CHAN *ochn;
unsigned char *in_ptr, *out_ptr;
int sum, ch;
if (sp_verbose > 15)
fprintf(spfp,
"Proc %s: Adding ULAW data %s %d\n",
proc, "channel",oc);
in_ptr = (unsigned char *)in_conversion_block;
out_ptr = (unsigned char *)out_block;
ochn = &(spifr->status->channels->ochan[oc]);
for (s=0; s<in_samples; s++){
for (ch=0, sum=0; ch < ochn->num_origin;
ch++){
sum +=
ulaw2linear_10_sbf_lut[
*(in_ptr+ochn->orig_channel[ch]-1)];
}
if (sum > 32767) sum = 32767;
else if (sum < -32768) sum = -32768;
*(out_ptr + oc) = linear2ulaw(sum);
in_ptr += in_chancnt;
out_ptr += out_chancnt;
}
}
}
out_block += out_recsize * in_samples;
}
if (spifr->status->user_data_fmt == SP_df_array){
/* convert the data from it's interleaved form */
/* to an array format */
int snb = spifr->status->user_sample_n_bytes;
int chcnt = spifr->status->user_channel_count;
int recsize = snb * chcnt;
char *in_dat;
if (sp_verbose > 15)
fprintf(spfp,"Proc %s: Converting data to an array\n",
proc);
if (arr_buff == (char **)0)
arr_buff = (char **)buffer;
for (c=0; c<chcnt; c++){
in_dat = current_data_location + (snb * c) ;
arr = arr_buff[c] + ((samples_read-in_samples) * snb);
for (s=0; s<in_samples; s++,arr+=snb,in_dat+=recsize)
memcpy(arr,in_dat,snb);
}
}
if (sp_verbose > 11){
fprintf(spfp,"Proc %s: Block %d: Requested %d samples",
proc,block++,num_sample);
fprintf(spfp," read %d total %d, Checksum %d (BC %d)\n",
ret,spifr->waveform->samples_read,
block_checksum,
spifr->waveform->checksum);
}
}
return_success(proc,0,samples_read,"ok");
}
