archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/enduser/netmeeting/av/codecs/lh/encoder.c

1625 lines
49 KiB
Raw Permalink Blame History

/*#define __TEST
#ifdef __TEST
#include <stdio.h>
FILE *test;
FILE *codage;
#endif*/
/*
* Project: Direct Subband 16000 bps coder and SBCELP 4800 bps coder
* Workfile: encoder.c
* Author: Alfred Wiesen
* Created: 30 August 1995
* Last update: 4 September 1995
* DLL Version: 1.00
* Revision: Single DLL for coder and decoder.
* Comment:
*
* (C) Copyright 1993-95 Lernout & Hauspie Speech Products N.V. (TM)
* All rights reserved. Company confidential.
*/
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Included files
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
#include <math.h>
#include <windows.h>
#include <windowsx.h>
#include "fv_x8.h"
#include "data.h"
#include "bib_32.h"
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Function prototypes
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
void InitializeCoderInstanceData(PVOID p, DWORD dwMaxBitRate);
void decimation_I(short input_I[],short coef_I[],short low_part_mem_I[],short order);
#if 0
// PhilF: The following is never called!!!
void quant_0a16_I2(short z1, short z2 ,short vec[], short maxv, short B1[], short B2[], long *code);
#endif
void quant_sous_bandes(PC16008DATA p,short *in,short *codes_max, long *codes_sb, short *indic_br/*, short *code_max_br*/);
void code_res_I(PC16008DATA p,short input[],short coef[],short qmf_mem[],short v_code[],long cod_long[], short ind_br[]/*, short c_max_br*/);
#ifdef CELP4800
void COEFF_A(PC4808DATA p),CALPITCH(PC4808DATA p),CHERCHE(PC4808DATA p);
void PERIODE(PC4808DATA p,short no),FRAME(PC4808DATA p);
void lsp_quant(PC4808DATA p,short lsp[],short nbit[],short bitdi[],short vcode[]);
void cal_dic1(PC4808DATA p,short *y,short *sr,short *espopt,short *posit,short dec,short esp,short sigpit[],short soulong,long tlsp[],long vmax[]);
//void cal_dic2(short q,short espace,short phase,short *s_r,short *hy,short *b,short *vois,short *esp,short *qq,short *phas,short sigpit[],short soulong,long tlsp[],long vmax[]);
void cal_dic2(PC4808DATA p,short q,short espace,short phase,short *s_r,short *hy,short *b,short *vois,short *esp,short *qq,short *phas);
#endif
void decimation(short *vin,short *vout,short nech);
/*void iConvert64To8(int *in, int *out, int N, int *mem);
void iConvert8To64(int *in, int *out, int N, int *mem);
void BandPass(int *,int *,int *,int);*/
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Global variables for coder
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/*#define MAXCODINGHANDLES 10
// Instance data structure
PC16008DATA pCoderData;
C16008DATA CoderData[MAXCODINGHANDLES];
int CodingHandles[MAXCODINGHANDLES];*/
// ROM tables :
extern short coef_I[]; // QMF filter coeffs
extern short B3_I[]; // Five levels quantification table
extern short B4_I[]; // Four levels quantification table
extern short B5_I[]; // Five levels quantification table
extern short B6_I[]; // Nine levels quantification table
extern short B7_I[]; // Nine levels quantification table
extern short B8_I[]; // Nine levels quantification table
extern short B9_I[]; // Nine levels quantification table
extern short max_level[]; // Quantified maximum sample level
extern long coeffs[];
extern long Mask[];
extern short hamming[];
extern short A0[];
extern short tabcos[];
extern short LSP_Q[];
extern short TAB_DI[];
extern short GQ[];
extern short GV[];
extern short BQ[];
extern short BV[];
extern short NBB[];
extern short BITDD[];
extern short LSP0ROM[];
//extern short quantif[];
//extern short bits[];
//extern short bytes[];
// RAM variables :
/*extern short codes_max[]; // Quantized max. of each subband
extern long codes_sb[]; // Two codes for each of the quantized subband
extern short indic_sp[]; // type of subband (1=noise; 0=to be decoded)
extern short code_max_br; // 1 bit for coding the noise
extern short DATA_I[]; // Intermediate vector = input and output of QMF
extern char stream[]; // Coded data buffer*/
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Function implementation
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
void InitializeCoderInstanceData(PVOID p, DWORD dwMaxBitRate)
// Instance data initializations
{
short i;
#ifdef CELP4800
if (dwMaxBitRate == 4800)
{
((PC4808DATA)p)->dwMaxBitRate = dwMaxBitRate;
((PC4808DATA)p)->mem_pit[0]=((PC4808DATA)p)->mem_pit[1]=69;
for (i=0;i<10;i++)
((PC4808DATA)p)->LSP0[i]=LSP0ROM[i];
}
else
#endif
{
((PC16008DATA)p)->dwMaxBitRate = dwMaxBitRate;
for (i=0;i<NBFAC;i++) ((PC16008DATA)p)->nbbit[i]=8; // On met les compteurs a "zero";
// on suppose demarrer par du bruit
((PC16008DATA)p)->MAX_LEVEL = MAX_LEVEL1; // valeur par defaut si le debit n'augmente pas trop
((PC16008DATA)p)->DIV_MAX = DIV_MAX1; // cad on ne traite pas les sb < 5% du max[i]
((PC16008DATA)p)->quantif[0] = 9;
((PC16008DATA)p)->quantif[1] = 9;
((PC16008DATA)p)->quantif[4] = 5;
((PC16008DATA)p)->quantif[5] = 5;
((PC16008DATA)p)->quantif[6] = 5;
((PC16008DATA)p)->quantif[7] = 5;
((PC16008DATA)p)->quantif[8] = 5;
((PC16008DATA)p)->quantif[9] = 5;
((PC16008DATA)p)->bits[0] = 52;
((PC16008DATA)p)->bits[2] = 38;
((PC16008DATA)p)->bits[3] = 38;
((PC16008DATA)p)->bits[4] = 38;
// Bug 3214: Just in case we get carried away, init the end of the arrays in both configurations
((PC16008DATA)p)->quantif[10] = 5;
((PC16008DATA)p)->quantif[11] = 5;
((PC16008DATA)p)->bits[5] = 38;
if (dwMaxBitRate == 16000)
{
((PC16008DATA)p)->NBSB_SP_MAX = NBSB_SP_MAX1_16000; // nbre max de sb pouvant etre du signal
((PC16008DATA)p)->quantif[2] = 7;
((PC16008DATA)p)->quantif[3] = 7;
((PC16008DATA)p)->bits[1] = 46;
}
else
{
((PC16008DATA)p)->NBSB_SP_MAX = NBSB_SP_MAX1_8000_12000; // nbre max de sb pouvant etre du signal
((PC16008DATA)p)->quantif[2] = 9;
((PC16008DATA)p)->quantif[3] = 9;
((PC16008DATA)p)->bits[1] = 52;
}
}
return;
}
//------------------------------------------------------------------------
void decimation_I(short input_I[],short coef_I[],short low_part_mem_I[],short order)
//
// Purpose : from data stored in DATA[], create the N_SB subbands
// Remark : output subband is stored at (input[]+N_SB*L_RES)
//
{
short i,j,lng;
short *low_out_part_I;
short *high_out_part_I;
short *buffer_I,*sa_vec_I;
buffer_I = low_part_mem_I;
for (i=0;i<N_SB;i++)
{
low_out_part_I=input_I+L_RES;
lng = L_RES >> (i+1);
high_out_part_I=low_out_part_I+lng;
sa_vec_I=low_out_part_I;
for (j=0;j<(1<<i);j++)
{
low_part_mem_I=buffer_I;
QMFilter(input_I,coef_I,low_out_part_I,high_out_part_I,low_part_mem_I,lng);
input_I += 2*lng; low_out_part_I += lng; high_out_part_I += lng;
if (j&1) high_out_part_I += 2*lng;
else low_out_part_I += 2*lng;
buffer_I += 2*order;
}
input_I=sa_vec_I;
}
}
#if 0
// PhilF: The following is never called!!!
//------------------------------------------------------------------------
void quant_0a16_I2(short z1, short z2, short vec[], short maxv, short B1[], short B2[], long *code)
// Quantifies the 16 samples of a subband on z levels using the table B[]
// Result stored in code[] (two long codes pro subband).
{
short i,x;
short ftmp;
long result;
result=0;
for (i=0;i<8;i++) // Quantify the first eight samples of the subband
{
ftmp=(((long)vec[i])<<13)/maxv;
x=0;
if (i==2*(short)(i/2))
{
while((ftmp>B1[x])&&(x<z1-1)) x++; result*=z1;
}
else
{
while((ftmp>B2[x])&&(x<z2-1)) x++; result*=z2;
}
result+=x; // Construct long code
}
*code=result; // Store code
result=0;
for (i=0;i<8;i++) // Quantify the last eight samples of the subband
{
ftmp=(((long)vec[i+8])<<13)/maxv;
x=0;
if (i==2*(short)(i/2))
{
while((ftmp>B1[x])&&(x<z1-1)) x++; result*=z1;
}
else
{
while((ftmp>B2[x])&&(x<z2-1)) x++; result*=z2;
}
result+=x; // Construct long code
}
*(code+1)=result; // Store code
}
#endif
void quant_0a16_I3(short z1, short z2, short vec[], short maxv, long *code)
// Quantifies the 16 samples of a subband on z levels using the table B[]
// Result stored in code[] (two long codes pro subband).
{
short i,x;
short ftmp;
long result;
short *B1,*B2;
switch (z1)
{
case 3: B1=B3_I; break;
case 4: B1=B4_I; break;
case 5: B1=B5_I; break;
case 6: B1=B6_I; break;
case 7: B1=B7_I; break;
case 8: B1=B8_I; break;
case 9: B1=B9_I; break;
// Bug 3214: Just in case we're passed a bogus value, set a default quantizer
default: B1=B5_I; break;
}
switch (z2)
{
case 3: B2=B3_I; break;
case 4: B2=B4_I; break;
case 5: B2=B5_I; break;
case 6: B2=B6_I; break;
case 7: B2=B7_I; break;
case 8: B2=B8_I; break;
case 9: B2=B9_I; break;
// Bug 3214: Just in case we're passed a bogus value, set a default quantizer
default: B2=B5_I; break;
}
result=0;
for (i=0;i<8;i++) // Quantify the first eight samples of the subband
{
ftmp=(((long)vec[i])<<13)/maxv;
x=0;
if (i==2*(short)(i/2))
{
while((ftmp>B1[x])&&(x<z1-1)) x++; result*=z1;
}
else
{
while((ftmp>B2[x])&&(x<z2-1)) x++; result*=z2;
}
result+=x; // Construct long code
}
*code=result; // Store code
result=0;
for (i=0;i<8;i++) // Quantify the last eight samples of the subband
{
ftmp=(((long)vec[i+8])<<13)/maxv;
x=0;
if (i==2*(short)(i/2))
{
while((ftmp>B1[x])&&(x<z1-1)) x++; result*=z1;
}
else
{
while((ftmp>B2[x])&&(x<z2-1)) x++; result*=z2;
}
result+=x; // Construct long code
}
*(code+1)=result; // Store code
}
//------------------------------------------------------------------------
void quant_sous_bandes(PC16008DATA p,short *in,short *codes_max, long *codes_sb, short *indic_sp)
// Quantifies the eight subbands
{
short max[8];
short order[8]={0,0,0,0,0,0,0,0};
short codes_max_loc[8]={0,0,0,0,0,0,0,0};
short maximum,max_num,ord,maxmax;
short i,j;
#ifdef MAX_SB_ABSOLU
short sb_count;
#endif
for (i=0;i<8;i++) // Quantify the maximums of the subbands
{
max[i]=0;
for (j=0;j<16;j++)
if (abs(*(in+16*i+j))>max[i]) max[i]=abs(*(in+16*i+j));
}
for (i=0;i<8;i++)
{
if (max[i]>2*max_level[31]) j = 31;
else for (j=0; max[i]>2*max_level[j]; j++);
codes_max_loc[i]=j;
max[i]=2*max_level[j];
} // fin quantifiation
p->nbbit_cf+=8; // 8 bits for the indic_sp
maxmax=0;
for (i=0;i<8;i++) // On cherche le plus grand maximum
{
if (max[i]>maxmax) maxmax=max[i];
}
maxmax/=p->DIV_MAX; // On le divise par 10 a 20 (cad a peu pres 10 a 5 %)
ord=8;
p->nbsb_sp=0;
for (i=0;i<8;i++) // Calculates the order of the subbands
{ // 1 is higher energy than 2 than 3,..
maximum=32767;
for (j=7;j>=0;j--)
{
if ((order[j]==0)&&(max[j]<maximum))
{
max_num=j; maximum=max[j];
}
}
order[max_num]=ord;
if ( (ord>p->NBSB_SP_MAX)||(maximum<=p->MAX_LEVEL)||(maximum<=maxmax) )
{
indic_sp[max_num]=0; // c'est 1 bande qui sera du bruit
}
else
{
indic_sp[max_num]=1;
p->nbsb_sp++;
}
ord--;
}
j=0;
for (i=0;i<8;i++)
{
if (indic_sp[i]==1)
{
codes_max[j]=codes_max_loc[i]; //5* 4 ou 5 bits suffisent
j++;
p->nbbit_cf+=5; // 5 bits per coded max
}
}
for (i=p->nbsb_sp-1;i>=0;i--)
{
j=0;
while (order[j]!=i+1) j++;
quant_0a16_I3(p->quantif[2*i],p->quantif[2*i+1],in+j*16,max[j],codes_sb+2*i);
p->nbbit_cf+=p->bits[i];
}
if (p->dwMaxBitRate == 16000)
{
j=0;
#ifdef MAX_SB_ABSOLU
sb_count=p->nbsb_sp;
if (sb_count>=MAX_SB_ABSOLU) return;
#endif
for (i=0;i<8;i++)
{
if (indic_sp[i]==0)
{
codes_max[p->nbsb_sp+j]=codes_max_loc[i]; //5* 4 ou 5 bits suffisent
j++;
p->nbbit_cf+=5; // 5 bits per coded max
#ifdef MAX_SB_ABSOLU
sb_count++;
quant_0a16_I3(SILENCE_QUANT_LEVEL_16000,SILENCE_QUANT_LEVEL_16000,in+i*16,max[i],codes_sb+2*sb_count);
p->nbbit_cf+=SILENCE_CODING_BIT_16000;
if (sb_count>=MAX_SB_ABSOLU) break;
#endif
}
}
#ifndef MAX_SB_ABSOLU
for (i=7;i>=p->nbsb_sp;i--)
{
j=0;
while (order[j]!=i+1) j++;
quant_0a16_I3(SILENCE_QUANT_LEVEL_16000,SILENCE_QUANT_LEVEL_16000,in+j*16,max[j],codes_sb+2*i);
p->nbbit_cf+=SILENCE_CODING_BIT_16000;
}
#endif
}
}
//------------------------------------------------------------------------
void code_res_I(PC16008DATA p,short input[],short coef[],short qmf_mem[],short v_code[],long cod_long[], short ind_br[]/*, short c_max_br*/)
{
decimation_I(input,coef,qmf_mem,Fil_Lenght);
quant_sous_bandes(p,input+3*L_RES,v_code,cod_long,ind_br/*AW,&c_max_br*/);
}
//------------------------------------------------------------------------
short Multiplexing(
char *Stream,
long *Codes,
short *CodeSizes,
short NumCodes,
short StreamSize)
{
short B,P; // B=bits … coder, P=bits libres
short i,j;
#ifdef __CHECK_FORMAT
long TotalBytes=0;
for (i=0;i<NumCodes;i++) TotalBytes+=CodeSizes[i];
if (TotalBytes>StreamSize*8) return 1;
#endif
i=0;
j=0;
B=CodeSizes[i]; // bits … coder
P=8; // 1 octet libre au d‚part
Stream[j]=0;
while (i<NumCodes)
{
if (P>B)
{
Stream[j]|=(Codes[i]&Mask[B])<<(P-B);
P-=B;
i++;
B=CodeSizes[i];
}
else if (P<B)
{
Stream[j]|=(Codes[i]>>(B-P))&Mask[P];
B-=P;
P=8;
j++;
Stream[j]=0;
}
else
{
Stream[j]|=Codes[i]&Mask[P];
i++;
j++;
P=8;
B=CodeSizes[i];
Stream[j]=0;
}
}
return 0;
}
// ------------------------------------------------------------------------
#ifdef CELP4800
void iteration(PC4808DATA p,long *P,short n,short *s)
{
short i;
p->a=0x7fffffffL;
for(i=0;i<7 ;i++)
{
horner(P,p->ttt,&p->a,n,*s);
horner(p->ttt,p->TLSP+12,&p->b,(short)(n-1),*s);
*s += calcul_s(p->a,p->b);
}
horner(P,p->ttt,&p->a,n,*s);
*(P+n) = 0;
long_to_long(p->ttt,P,n);
}
// ------------------------------------------------------------------------
void ai_to_lsp(PC4808DATA p,long *ai_pq,short *lsp)
{
short s; short n;
ai_to_pq(ai_pq,10);
s=0x7fff;
p->ptr1 = lsp;
for(n=5; n>2; n--)
{
iteration(p,ai_pq,n,&s);
*p->ptr1++ = s;
if (lsp[0]<0) lsp[0]=s=32765;
iteration(p,ai_pq+6,n,&s);
*p->ptr1++ = s;
}
binome(lsp+6,ai_pq);
}
// ------------------------------------------------------------------------
void cal_dic1(PC4808DATA p,short *y,short *sr,short *espopt,short *posit,short dec,short esp,
short *sigpi,short soulong,long *tlsp,long *vmax)
{
short i,k,limite;
long *vene;
vene = (long *)(sigpi+150);
venergy(y,vene,soulong);
k=soulong-1;
for (i=0;i<dec;i++)
{
p->ptr1 = sr;limite=i;
*tlsp = *(p->ptr1+limite); limite += esp;
while (limite<soulong) { *tlsp += *(p->ptr1+limite); limite += esp;}
*(tlsp+1) = *(vene+k-i);
limite=upd_max_d(tlsp,vmax);
if (limite) {*posit=i; *espopt=esp; *posit=i; *espopt=esp;}
}
}
// ------------------------------------------------------------------------
void cal_dic2(PC4808DATA p,short q,short espace,short phase,short *s_r,short *hy,
short *b,short *vois,short *esp,short *qq,short *phas)
{
short i,j,i0,k;
short src[10],*y2; short cc[10];
long R11;
y2 = p->SIGPI+75;
R11 = 0;
init_zero(y2,p->SOULONG);
for (j=0;j<q;j++)
{
i0=espace*j+phase;
src[j]=s_r[i0];
}
for (j=0;j<q;j++) if (src[j]>0) cc[j]=1;
else cc[j]=-1;
for (i=0;i<q;i++) R11 += abs(src[i]);
for (j=0;j<q;j++)
{
i0=espace*j+phase;
k=cc[j];
if (k>0)
{
add_sf_vect(y2,hy,i0,p->SOULONG);
}
else
{
sub_sf_vect(y2,hy,i0,p->SOULONG);
}
}
energy2(y2,p->TLSP+1,p->SOULONG);
*p->TLSP=R11;
i = upd_max_d(p->TLSP,p->VMAX);
if (i) { short_to_short(cc,b,q); *vois=0; *esp=espace; *qq=q; *phas=phase; }
/* for (i=0;i<q;i++)
{
cc[i]=-cc[i];
*TLSP = R11 + 2*src[i]*cc[i];
k=2*cc[i];
i0=espace*i+phase;
update_dic(y1,y2,hy,SOULONG,i0,k);
energy2(y1,TLSP+1,SOULONG);
k = upd_max_d(TLSP,VMAX);
if (k)
{
short_to_short(cc,b,q);
R11 = *TLSP;
my2=y1; y1=y2; y2=my2;
*vois=0; *esp=espace; *qq=q; *phas=phase;
}
else cc[i]=-cc[i];
}*/
}
/*-------------------------------------------------------------------------
Review version of CAL_DIC2
{
R11 = 0;
init_zero(y2,SOULONG);
i0=phase-espace;
for (j=0;j<q;j++)
{
i0+=espace;
src[j]=s_r[i0];
if (src[j]>0)
{
cc[j]=1;
R11 += (long)(src[j]);
add_sf_vect(y2,hy,i0,SOULONG);
}
else
{
cc[j]=-1;
R11 -= (long)(src[j]);
sub_sf_vect(y2,hy,i0,SOULONG);
}
}
energy2(y2,TLSP+1,SOULONG);
*TLSP=R11;
i = upd_max_d(TLSP,VMAX);
if (i) { short_to_short(cc,b,q); *vois=0; *esp=espace; *qq=q; *phas=phase; }
i0=phase-espace;
for (i=0;i<q;i++)
{
cc[i]=-cc[i];
*TLSP = R11 + 2*src[i]*cc[i];
k=2*cc[i];
i0+=espace;
update_dic(y1,y2,hy,SOULONG,i0,k);
energy2(y1,TLSP+1,SOULONG);
k = upd_max_d(TLSP,VMAX);
if (k)
{
short_to_short(cc,b,q);
R11 = *TLSP;
my2=y1; y1=y2; y2=my2;
*vois=0; *esp=espace; *qq=q; *phas=phase;
}
else cc[i]=-cc[i];
}
}
-----------------------------------------------------------------------*/
// ------------------------------------------------------------------------
void left_correl(PC4808DATA p,short vech[],short debut,short fin,short pitch,short delta,long *vv)
{
short i,k,lng;
lng=fin-debut+1;
i=pitch-delta;
energy(vech+debut-i,p->TLSP+2,lng);
correlation(vech+debut-i,vech+debut,p->TLSP,lng);
norm_corrl(vv,p->TLSP);
for (i=pitch-delta+1;i<=pitch+delta;i++)
{
correlation(vech+debut-i,vech+debut,p->TLSP,lng);
p->TLSP[10] = (long)vech[debut-i]*(long)vech[debut-i];
p->TLSP[11] = (long)vech[fin-i+1]*(long)vech[fin-i+1];
upd_ene(p->TLSP+2,p->TLSP+10);
k=i-pitch+delta;
norm_corrl(vv+2*k,p->TLSP);
}
}
// ------------------------------------------------------------------------
void right_correl(PC4808DATA p,short vech[],short debut,short fin,short pitch,short delta,long *vv)
{
short i,k,lng;
lng=fin-debut+1;
i=pitch-delta;
energy(vech+debut+i,p->TLSP+2,lng);
correlation(vech+debut+i,vech+debut,p->TLSP,lng);
norm_corrr(vv,p->TLSP);
for (i=pitch-delta+1;i<=pitch+delta;i++)
{
correlation(vech+debut+i,vech+debut,p->TLSP,lng);
p->TLSP[11]=(long)vech[debut+i-1]*(long)vech[debut+i-1];
p->TLSP[10]=(long)vech[fin+i]*(long)vech[fin+i];
upd_ene(p->TLSP+2,p->TLSP+10);
k=i-pitch+delta;
norm_corrr(vv+2*k,p->TLSP);
}
}
// ------------------------------------------------------------------------
void COEFF_A(PC4808DATA p)
{
fenetre(p->SIG+SOUDECAL1-RECS2,hamming,p->SIGPI,NECHFEN);
autocor(p->SIGPI,p->TLSP,NECHFEN,NETAGES);
// TLSP[0]=ldiv(TLSP[0]*1001L,1000L);
if (*p->TLSP)
{
schur(p->LSP,p->TLSP,NETAGES);
ki_to_ai(p->LSP,p->TLSP,NETAGES);
ai_to_lsp(p,p->TLSP,p->LSP);
cos_to_teta(tabcos,p->LSP,10);
}
else short_to_short(p->LSP0,p->LSP,10);
lsp_quant(p,p->LSP,NBB,BITDD,p->code);
short_to_short(p->LSP,p->A3,10);
teta_to_cos(tabcos,p->A3,10);
lsp_to_ai(p->A3,p->TLSP,10);
interpol(p->LSP0,p->LSP,p->A1,NETAGES);
teta_to_cos(tabcos,p->A1,10);
lsp_to_ai(p->A1,p->TLSP,10);
interpol(p->LSP,p->LSP0,p->A2,NETAGES);
teta_to_cos(tabcos,p->A2,10);
lsp_to_ai(p->A2,p->TLSP,10);
short_to_short(p->LSP,p->LSP0,NETAGES);
}
// ------------------------------------------------------------------------
void lsp_quant(PC4808DATA p,short lsp[],short nbit[],short bitdi[],short vcode[])
{
short i,iopt,k,nombi,m,m1,k2;
short *delta,*lsptab,dmin,tmp,demi;
delta = p->E;
lsptab = LSP_Q;
m1 = NETAGES/2;
for (i=0;i<nbit[0];i++) delta[i]=abs(lsp[0] - *(lsptab+i) );
dmin=delta[0];
iopt=0;
for (i=1;i<nbit[0];i++)
if (delta[i]<dmin)
{
dmin=delta[i];
iopt=i;
}
lsp[0] = *(lsptab+iopt);
vcode[0]=iopt;
for (k=1;k<m1;k++)
{
k2=2*k;
lsptab += nbit[k-1];
for (i=0;i<nbit[k];i++) delta[i]=abs(lsp[k2] - *(lsptab+i));
dmin=32767;
tmp=lsp[k2-1];
if (tmp<lsp[k2-2]) tmp=lsp[k2-2];
for (i=0;i<nbit[k];i++)
if (*(lsptab+i)>tmp)
if (delta[i]<dmin)
{
dmin=delta[i];
iopt=i;
}
lsp[k2] = *(lsptab+iopt);
vcode[k2] = iopt;
}
lsptab = TAB_DI;
for (k=0; k<m1-1; k++)
{
k2 = k<<1;
m=bitdi[k];
nombi = (m-1)<<1;
demi=(lsp[k2+2]-lsp[k2]+1)>>1;
for (i=0;i<m;i++)
delta[i]=lsp[k2] + (short)(((long)*(lsptab++)* (long)demi+(long)16384<<1)>>16);
for (i=0;i<m-2;i++) delta[m+i]=lsp[k2+2] - (short)(((long)*(lsptab++) * (long)demi+(long)16384<<1)>>16);
dmin=32767;
for (i=0;i<nombi;i++)
{
tmp = abs(lsp[k2+1]-delta[i]);
if (tmp<dmin)
{
iopt=i;
dmin=tmp;
}
}
lsp[k2+1]=delta[iopt];
vcode[k2+1]=iopt;
}
m=bitdi[k];
nombi=(m-1)<<1;
demi=(32767-lsp[8]+1)>>1;
for (i=0;i<m;i++) delta[i] = lsp[8] + (short)(((long)*(lsptab++) * (long)demi+(long)16384<<1)>>16);
dmin=32767;
for (i=0;i<nombi;i++)
{
tmp = abs(lsp[9]-delta[i]);
if (tmp<dmin)
{
iopt=i;
dmin=tmp;
}
}
lsp[9]=delta[iopt];
vcode[9]=iopt;
}
// ------------------------------------------------------------------------
void RESIDU(PC4808DATA p,short no)
{
short i0;
switch (no)
{
case 0:
i0=0;
break;
case 1: short_to_short(p->A2,p->A1,11);
i0=SOUDECAL1;
break;
case 2: short_to_short(p->A3,p->A1,11);
i0=SOUDECAL1+SOUDECAL;
break;
}
f_inverse(p->MINV,p->A1,p->SIG+i0,p->E,p->SOULONG,NETAGES);
}
// ------------------------------------------------------------------------
void PERIODE(PC4808DATA p,short no)
{
short i,P1,P2;
short *y0,*y1,*y2;
short MAX,MAX2,j,bit_garde;
y0=p->SIGPI; y2=y0+75; y1=p->E_PE;
fenetre(p->A1,A0,p->Aw,11);
init_zero(p->zz,12);
p->H[0]=4096;
init_zero(p->H+1,(short)(p->SOULONG-1));
synthesis(p->zz,p->Aw,p->H,p->H,35,NETAGES,0);
if (no)
{
P1=p->PITCH-3;
if (P1<LIM_P1) P1=LIM_P1;
P2=p->PITCH+4;
if (P2>LIM_P2) P2=LIM_P2;
}
else
{
P1=p->PITCH-5;
if (P1<LIM_P1) P1=LIM_P1;
P2=p->PITCH+5;
if (P2>LIM_P2) P2=LIM_P2;
}
// calc_p(&P1,&P2,PITCH,LIM_P1,LIM_P2,no);
MAX = max_vect(p->E,p->SOULONG);
if (P2<p->SOULONG) MAX2 = max_vect(p->EE+lngEE-P2,P2);
else
{
if (P1<p->SOULONG) j=P1+16;
else j=p->SOULONG+16;
MAX2 = max_vect(p->EE+lngEE-P2,j);
}
if (MAX2>MAX) MAX=MAX2;
if (MAX & 0xe000)
{
i=MAX >> 13;
if (!(i>>1)) bit_garde=1;
else bit_garde=2;
}
else bit_garde=0;
init_zero(p->zz,12);
synthesis(p->zz,p->Aw,p->E,y1,p->SOULONG,NETAGES,bit_garde);
if (P1<p->SOULONG)
{
short_to_short(p->EE+lngEE-P1,y0,P1);
for (i=P1;i<p->SOULONG;i++) y0[i]=0;
}
else short_to_short(p->EE+lngEE-P1,y0,p->SOULONG);
init_zero(p->zz,12);
synthesis(p->zz,p->Aw,y0,y0,p->SOULONG,NETAGES,bit_garde);
short_to_short(y0,y2,p->SOULONG);
if (P1<p->SOULONG) add_sf_vect(y2,y0,P1,p->SOULONG);
if (2*P1<p->SOULONG) add_sf_vect(y2,y0,(short)(P1<<1),p->SOULONG);
energy(y2,p->TLSP+2,p->SOULONG);
correlation(y1,y2,p->TLSP,p->SOULONG);
p->VMAX[1]=-6969;
p->VMAX[4]=P1;
upd_max(p->TLSP,p->VMAX,P1);
for (i=P1+1;i<=P2;i++)
{
p->ptr1=y0; y0=y2; y2=p->ptr1;
update_ltp(y0,y2,p->H+1,p->SOULONG,bit_garde,p->EE[lngEE-i]);
if (i<p->SOULONG)
{
short_to_short(y0,y2,p->SOULONG);
add_sf_vect(y2,y0,i,p->SOULONG);
if (2*i<p->SOULONG) add_sf_vect(y2,y0,(short)(i<<1),p->SOULONG);
energy(y2,p->TLSP+2,p->SOULONG);
correlation(y1,y2,p->TLSP,p->SOULONG);
}
else
{
energy(y0,p->TLSP+2,p->SOULONG);
correlation(y1,y0,p->TLSP,p->SOULONG);
}
upd_max(p->TLSP,p->VMAX,i);
}
#if 0
//*(p->VMAX+2) = 28265821L;
//*(p->VMAX+3) = 61L;
//*(p->VMAX+2) = 881427L;
//*(p->VMAX+3) = 1L;
//*(p->VMAX+2) = 9851363L;
//*(p->VMAX+3) = 6L;
//*(p->VMAX+2) = 812881L;
//*(p->VMAX+3) = 2L;
#if 1
// Save jmp
if ((*(p->VMAX+2) < 0L) || (*(p->VMAX+3) == 0L) || (((long)((long)(*(p->VMAX+2))/(long)(*(p->VMAX+3))) & 0xFFFC0000) == 0L))
proc_gain(p->VMAX+2,p->ttt);
else
*(p->ttt) = 0L; // *(p->VMAX+3) = 0L;
#else
if ((*(p->VMAX+2) > 0L) && (*(p->VMAX+3)) && ((long)((long)(*(p->VMAX+2))/(long)(*(p->VMAX+3))) & 0x0FFC0000))
{
*(p->ttt) = 0L; // *(p->VMAX+3) = 0L;
}
else
proc_gain(p->VMAX+2,p->ttt);
#endif
#else
//*(p->VMAX+2) = 28265821L;
//*(p->VMAX+3) = 61L;
//*(p->VMAX+2) = 881427L;
//*(p->VMAX+3) = 1L;
//*(p->VMAX+2) = 9851363L;
//*(p->VMAX+3) = 6L;
//*(p->VMAX+2) = 812881L;
//*(p->VMAX+3) = 2L;
proc_gain(p->VMAX+2,p->ttt);
#endif
p->PITCH=(short)p->VMAX[4];
/*
if (ttt[0]>32767) GLTP=32767;
else
if (ttt[0]<-32767) GLTP=-32767;
else GLTP=ttt[0];
m = abs(GLTP);
for (i=1;i<=10;i++) if ((m>=BQ[i-1])&&(m<BQ[i]))
{
if (GLTP>0) { GLTP=BV[i] ; k=i-1; }
else { GLTP=-BV[i]; k=i+10-1; }
break;
}
if (GLTP>=BQ[10]) { GLTP=BV[10]; k=9; }
if (GLTP<-BQ[6]) { GLTP=-BV[6]; k=15 ; }
*/
p->code[11+p->depl]=calc_gltp(&p->GLTP,BQ,BV,p->ttt[0]);;
p->code[10+p->depl]=p->PITCH;
if (p->PITCH<p->SOULONG)
{
short_to_short(p->EE+lngEE-p->PITCH,p->E_PE,p->PITCH);
short_to_short(p->E_PE,p->E_PE+p->PITCH,(short)(p->SOULONG-p->PITCH));
mult_fact(p->E_PE,p->E_PE,p->GLTP,p->SOULONG);
}
else
{
mult_fact(p->EE+lngEE-p->PITCH,p->E_PE,p->GLTP,p->SOULONG);
}
}
// ------------------------------------------------------------------------
void CHERCHE(PC4808DATA p)
{
short i;
short position,esp_opt;
short k,j;
short c[10],VOISE,npopt,phas_opt,cod,sign;
short Gopt;
short *sr,*y0;
short MAX,bit_garde;
sr=p->SIGPI; y0=sr+75;
for (i=0;i<p->SOULONG;i++) p->E[i] -= p->E_PE[i];
init_zero(p->zz,12);
synthesis(p->zz,p->Aw,p->E,sr,p->SOULONG,NETAGES,0);
MAX = max_vect(sr,p->SOULONG);
/* if (MAX & 0xfe00)
{
i=MAX >> 9;
if (!(i>>1)) bit_garde=1;
else if (!(i>>2)) bit_garde=2;
else if (!(i>>3)) bit_garde=3;
else if (!(i>>4)) bit_garde=4;
else if (!(i>>5)) bit_garde=5;
else bit_garde=6;
}
else bit_garde=0;
*/
bit_garde=calc_garde(MAX);
inver_v_int(sr,y0,p->SOULONG);
init_zero(p->zz,12);
synthesis(p->zz,p->Aw,y0,y0,p->SOULONG,NETAGES,bit_garde);
inver_v_int(y0,sr,p->SOULONG);
p->VMAX[0]=-6969;
Gopt=position=0;
VOISE=1;
if ( !p->UNVOIS )
{
esp_opt=p->PITCH;
short_to_short(p->H,y0,p->SOULONG);
if (p->PITCH<p->SOULONG) add_sf_vect(y0,p->H,p->PITCH,p->SOULONG);
// cal_dic1(y0,sr,&esp_opt,&position,SOULONG,PITCH);
cal_dic1(p,y0,sr,&esp_opt,&position,p->SOULONG,p->PITCH,p->SIGPI,p->SOULONG,p->TLSP,p->VMAX);
/* if (PITCH>=SOULONG)
{
if (PITCH/2<SOULONG) sign = PITCH/2;
else sign=PITCH/3;
short_to_short(H,y0,SOULONG);
add_sf_vect(y0,H,sign,SOULONG);
// cal_dic1(y0,sr,&esp_opt,&position,54,sign);
cal_dic1(y0,sr,&esp_opt,&position,54,sign,SIGPI,SOULONG,TLSP,VMAX);
}
// else cal_dic1(H,sr,&esp_opt,&position,54,SOULONG+5);
else cal_dic1(H,sr,&esp_opt,&position,54,SOULONG+5,SIGPI,SOULONG,TLSP,VMAX);
*/
}
cal_dic2(p,8,7,0,sr,p->H,c,&VOISE,&esp_opt,&npopt,&phas_opt);
cal_dic2(p,7,8,3,sr,p->H,c,&VOISE,&esp_opt,&npopt,&phas_opt);
/*
cal_dic2(8,7,0,sr,H,c,&VOISE,&esp_opt,&npopt,&phas_opt,SIGPI,SOULONG,TLSP,VMAX);
cal_dic2(7,8,3,sr,H,c,&VOISE,&esp_opt,&npopt,&phas_opt,SIGPI,SOULONG,TLSP,VMAX);
*/
proc_gain2(p->VMAX+1,p->VMAX,bit_garde);
if (p->VMAX[0]>32767) Gopt=32767;
else if (p->VMAX[0]<-32767) Gopt=-32767;
else Gopt=(short)p->VMAX[0];
if (VOISE==0)
{
if (c[0]==-1)
{
Gopt=-Gopt;
for (k=0;k<npopt;k++) c[k]=-c[k];
}
if (npopt==7) cod = 64;
else cod = 128;
for (j=1;j<npopt;j++)
if (c[j]==1) cod += 1 << (npopt-j-1);
}
else
{
if (esp_opt == p->PITCH) cod=position;
else cod = position+SOUDECAL1;
}
p->code[12+p->depl]=cod;
if (Gopt<0) { Gopt=-Gopt; sign=1; }
else sign=0;
for (i=1;i<=16;i++) if ((Gopt>=GQ[i-1])&&(Gopt<GQ[i]))
{
Gopt=GV[i];
cod=i-1;
break;
}
if (Gopt>=GQ[16]) { Gopt=GV[16]; cod=15; }
if (sign) { Gopt = -Gopt; cod += 16; }
p->code[13+p->depl]=cod;
// Gopt=calc_gopt(c,code,GQ,GV,VOISE,npopt,PITCH,esp_opt,depl,position,SOUDECAL1,VMAX[0]);
short_to_short(p->E_PE,p->E,p->SOULONG);
if (VOISE==1)
{
i=0;
do
{
p->E[position+i] += Gopt;
i += esp_opt;
}
while ((position+i)<p->SOULONG);
}
else
for (j=0;j<npopt;j++)
p->E[esp_opt*j+phas_opt] += c[j]*Gopt;
short_to_short(p->EE+p->SOULONG,p->EE,(short)(lngEE-p->SOULONG));
short_to_short(p->E,p->EE+lngEE-p->SOULONG,p->SOULONG);
}
// ------------------------------------------------------------------------
void FRAME(PC4808DATA p)
// Purpose : concatenate all parameters
// Input parameter :
// code[] : parameters code
// Output parameter :
// output_stream[] : multiplexed code
//
// Comments: The LTP or Adaptive codebook is also called PITCH.
//
// Bit allocation : Codebook or gain "i" is the codebook for suboutput_stream "i".
// code[0] = LSP(0) : 3bits code[10] = LTP codebook 1 : 7bits
// code[1] = LSP(1) : 4bits code[11] = LTP gain 1 : 4bits
// code[2] = LSP(2) : 4bits code[12] = Binary codebook 1 : 8bits
// code[3] = LSP(3) : 3bits code[13] = Binary gain 1 : 5bits
// code[4] = LSP(4) : 4bits code[14] = LTP codebook 2 : 4bits
// code[5] = LSP(5) : 3bits code[15] = LTP gain 2 : 4bits
// code[6] = LSP(6) : 3bits code[16] = Binary codebook 2 : 8bits
// code[7] = LSP(7) : 2bits code[17] = Binary gain 2 : 5bits
// code[8] = LSP(8) : 3bits code[18] = LTP codebook 3 : 4bits
// code[9] = LSP(9) : 1bits code[19] = LTP gain 3 : 4bits
// code[20] = Binary codebook 3 : 8bits
// code[21] = Binary gain 3 : 5bits
//
// output_stream[0] = LSP[0] | LSP[1] | LSP[2] | (Binary gain 2)
// output_stream[1] = LSP[3] | (Binary gain 3) | (Binary codebook 1)
// output_stream[2] = LSP[4] | LSP[5] | LSP[6] | LSP[7] | LSP[8] | LSP[9]
// output_stream[3] = (LTP codebook 1) | (LTP gain 1) | (Binary gain 1)
// output_stream[4] = (LTP codebook 2) | (LTP gain 2) | (Binary codebook 2)
// output_stream[5] = (LTP codebook 3) | (LTP gain 3) | (Binary codebook 3)
{
p->code[18] = p->code[18]-p->code[14]+7;
p->code[14] = p->code[14]-p->code[10]+7;
p->code[10] -= LIM_P1;
p->output_frame[0] = (p->code[0]<<13) | (p->code[1]<<9) | (p->code[2]<<5) | p->code[17];
p->output_frame[1] = (p->code[3]<<13) | (p->code[21]<<8) | p->code[12];
p->output_frame[2] = (p->code[4]<<12) | (p->code[5]<<9) | (p->code[6]<<6) | (p->code[7]<<4) | (p->code[8]<<1) | p->code[9];
p->output_frame[3] = (p->code[10]<<9) | (p->code[11]<<5) | p->code[13];
p->output_frame[4] = (p->code[14]<<12) | (p->code[15]<<8) | p->code[16];
p->output_frame[5] = (p->code[18]<<12) | (p->code[19]<<8) | p->code[20];
/*
code[18] = code[18]-code[14]+3;
code[14] = code[14]-code[10]+3;
code[10] -= LIM_P1;
output_frame[0] = (code[0]<<13) | (code[1]<<9) | code[12];
output_frame[1] = (code[3]<<13) | (code[2]<<9) | code[16];
output_frame[2] = (code[5]<<13) | (code[4]<<9) | code[20];
output_frame[3] = (code[10]<<9) | (code[6]<<6) | (code[14]<<3) | code[18];
output_frame[4] = (code[11]<<12) | (code[15]<<8) | (code[19]<<4) | (code[7]<<2) | code[8];
output_frame[5] = (code[13]<<11) | (code[17]<<6) | (code[21]<<1) | code[9];
*/
}
// ------------------------------------------------------------------------
void CALPITCH(PC4808DATA p)
{
short P1,P2,P3,j0,j1,L;
/* long GG;
GG=0;
for (j=0;j<NECHFEN;j++) GG += (long)abs(SIG[SOUDECAL1-RECS2+j]);
GG /= NECHFEN;
if (GG<69) UNVOIS=1;
else UNVOIS=0;*/
L=NECHFEN+DECAL;
p->ialf=0;
deacc(p->M_PIT,p->SIGPI+10,29491,150,&p->ialf);
deacc(p->SIG+SOUDECAL1-RECS2,p->SIGPI+160,29491,211,&p->ialf);
j0=(L-80)/2;
j1=j0+80;
/*
filt_iir(memfil_calp,coef_calp,SIGPI+10,SIG_CALP,361,3); // filtrage
for (j=0;j<90;j++) SIG_CALP[j]=SIG_CALP[4*j]; //d‚cimation par 4
*/
//// decime(SIGPI+10,SIG_CALP,coef_calp,Zai,Zbi,361);
decimation(p->SIGPI+10,p->SIG_CALP,90);
P1=max_autoc(p->SIG_CALP+40,28,5,14)*4;
P2=max_autoc(p->SIG_CALP+20,56,13,28)*4;
/* P1=max_autoc(SIGPI+160,130,LIM_P1,LIM_P1+35);
P2=max_autoc(SIGPI+160-80,280,LIM_P1+30,LIM_P2);
*/
P3=P2/2; p->ialf=P2/3;
if ( (p->ialf>p->mem_pit[0]-17)&&(p->ialf<p->mem_pit[0]+17) && (abs(p->mem_pit[0]-p->ialf)<abs(p->mem_pit[0]-P3))) P3=p->ialf;
left_correl(p,p->SIGPI,j0,j1,P1,2,p->veci1);
left_correl(p,p->SIGPI,j0,j1,P2,2,p->veci2);
left_correl(p,p->SIGPI,j0,j1,P3,2,p->veci3);
right_correl(p,p->SIGPI,j0,j1,P1,2,p->veci1);
right_correl(p,p->SIGPI,j0,j1,P2,2,p->veci2);
right_correl(p,p->SIGPI,j0,j1,P3,2,p->veci3);
P1=max_posit(p->veci1,p->TLSP,P1,5);
P2=max_posit(p->veci2,p->TLSP+2,P2,5);
P3=max_posit(p->veci3,p->TLSP+4,P3,5);
if (p->TLSP[1]>p->TLSP[3]) p->PITCH =P1;
else if ((p->TLSP[1]==p->TLSP[3]) && (p->TLSP[0]>p->TLSP[2])) p->PITCH=P1;
else { p->PITCH=P2; p->TLSP[0]=p->TLSP[2]; p->TLSP[1]=p->TLSP[3];}
if ( (P3>p->mem_pit[0]-17) && (P3<p->mem_pit[0]+17))
{
if (abs(p->mem_pit[1]-p->mem_pit[0])<15) p->TLSP[0] = p->TLSP[0]>>1 + p->TLSP[0]>>2;
if (abs(P3-P1)>6) p->TLSP[0] = p->TLSP[0]>>1 + p->TLSP[0]>>2;
if (p->TLSP[0]<0x40000000L) { p->TLSP[0]<<=1; p->TLSP[1]--;}
// if (TLSP[0]<0x40000000) { TLSP[0]<<=1; TLSP[1]--;}
if (p->TLSP[1]<p->TLSP[5]) p->PITCH =P3;
else if ((p->TLSP[1]==p->TLSP[5]) && (p->TLSP[0]<p->TLSP[4])) p->PITCH=P3;
}
p->mem_pit[1]=p->mem_pit[0];
p->mem_pit[0]=p->PITCH;
}
#endif
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// DLL entry points
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
LH_PREFIX HANDLE LH_SUFFIX MSLHSB_Open_Coder(DWORD dwMaxBitRate)
{
PVOID pCoderData;
/*short i,flag=0;
// Test if there are free handles
for (i=0;i<MAXCODINGHANDLES;i++)
if (CodingHandles[i]==0) {CodingHandles[i]=1; flag=1; break;}
if (flag==0) return 0;
pCoderData=&CoderData[i];*/
// Check the input bit rate param.
if (
#ifdef CELP4800
(dwMaxBitRate != 4800) &&
#endif
(dwMaxBitRate != 8000) && (dwMaxBitRate != 12000) && (dwMaxBitRate != 16000))
return (HANDLE)0;
// pCoderData=(PVOID)GlobalAllocPtr(GMEM_MOVEABLE, dwMaxBitRate == 4800 ? sizeof(C4808DATA) : sizeof(C16008DATA));
#ifdef CELP4800
pCoderData=(PVOID)GlobalAllocPtr(GHND, dwMaxBitRate == 4800 ? sizeof(C4808DATA) : sizeof(C16008DATA));
#else
pCoderData=(PVOID)GlobalAllocPtr(GHND, sizeof(C16008DATA));
#endif
if (pCoderData==NULL)
return (HANDLE)0;
InitializeCoderInstanceData(pCoderData, dwMaxBitRate);
#ifdef __TEST
codage=(FILE*)fopen("codage.dat","wb");
test=(FILE*)fopen("codes_c2.dat","wt");
#endif
return((HANDLE)pCoderData);
}
// ------------------------------------------------------------------------
LH_PREFIX LH_ERRCODE LH_SUFFIX MSLHSB_Encode(
HANDLE hAccess,
LPBYTE lpSrcBuf,
LPWORD lpSrcBufSize,
LPBYTE lpDstBuf,
LPWORD lpDstBufSize)
{
short i,iNBSPF,iMOD_TH1,iMOD_TH2,iMOD_TH3,k,flag=0;
short iNBSB_SP_MAX1,iNBSB_SP_MAX2,iNBSB_SP_MAX3,iNBSB_SP_MAX4;
short *input;
short *in;
unsigned short *ptr2,*ptr4;
unsigned char *ptr1,*ptr3;
long nbb_ave; // Average bit rate on the previous NBFAC frames of speech
short codesizes[24];
long codes[24];
short numcodes,temp;
short ivect8[160];
PVOID pCoderData;
if ((!hAccess) || (!lpSrcBuf) || (!lpDstBuf))
return LH_EBADARG;
// First check that the handle provided as argument is correct
/*for (i=0;i<MAXCODINGHANDLES;i++)
if ((CodingHandles[i]==1)&&(hAccess==(HANDLE)&CoderData[i])) {flag=1; break;}
if (flag==0) return LH_BADHANDLE;*/
pCoderData=(PVOID)hAccess;
// Check the input bit rate param.
if (
#ifdef CELP4800
(((PC4808DATA)pCoderData)->dwMaxBitRate != 4800) &&
#endif
(((PC16008DATA)pCoderData)->dwMaxBitRate != 8000) &&
(((PC16008DATA)pCoderData)->dwMaxBitRate != 12000) &&
(((PC16008DATA)pCoderData)->dwMaxBitRate != 16000))
return (LH_ERRCODE)LH_EBADARG;
#ifdef CELP4800
if ((((PC4808DATA)pCoderData)->dwMaxBitRate == 4800))
{
// then check the buffer sizes passed as argument.
if ((*lpSrcBufSize<2*NECHDECAL)||(*lpDstBufSize<12))
return (LH_ERRCODE)LH_EBADARG;
*lpSrcBufSize=2*NECHDECAL;
*lpDstBufSize=12;
input = (short *)lpSrcBuf;
in=((PC4808DATA)pCoderData)->SIG+SOUDECAL1+RECS2;
for (i=0;i<DECAL;i++) *in++=*input++;
filt_in(((PC4808DATA)pCoderData)->mem2,((PC4808DATA)pCoderData)->SIG+SOUDECAL1+RECS2,((PC4808DATA)pCoderData)->SIG+SOUDECAL1+RECS2,DECAL);
CALPITCH(((PC4808DATA)pCoderData));
COEFF_A(((PC4808DATA)pCoderData));
for (i=0;i<3;i++)
{
if (i==0) ((PC4808DATA)pCoderData)->SOULONG=SOUDECAL1;
else ((PC4808DATA)pCoderData)->SOULONG=SOUDECAL;
((PC4808DATA)pCoderData)->depl=i*4;
RESIDU(((PC4808DATA)pCoderData),i);
PERIODE(((PC4808DATA)pCoderData),i);
CHERCHE(((PC4808DATA)pCoderData));
dsynthesis(((PC4808DATA)pCoderData)->DMSY,((PC4808DATA)pCoderData)->A1,((PC4808DATA)pCoderData)->E,((PC4808DATA)pCoderData)->E_PE,((PC4808DATA)pCoderData)->SOULONG,NETAGES);
for (k=0;k<=11;k++) ((PC4808DATA)pCoderData)->MINV[12-k] = ((PC4808DATA)pCoderData)->E_PE[((PC4808DATA)pCoderData)->SOULONG-12+k];
((PC4808DATA)pCoderData)->MINV[0]=(short)(((PC4808DATA)pCoderData)->DMSY[0] >> 16);
}
FRAME(((PC4808DATA)pCoderData));
short_to_short(((PC4808DATA)pCoderData)->SIG+SOUDECAL1-RECS2,((PC4808DATA)pCoderData)->M_PIT,160);
short_to_short(((PC4808DATA)pCoderData)->SIG+NECHDECAL,((PC4808DATA)pCoderData)->SIG,SOUDECAL1+RECS2);
ptr4 = (unsigned short *)&((PC4808DATA)pCoderData)->output_frame;
ptr2 = (unsigned short *)lpDstBuf;
for (i =0;i<6;i++) ptr2[i] = ptr4[i];
}
else
#endif
{
input = (short *)lpSrcBuf;
((PC16008DATA)pCoderData)->nbbit_cf=0;
// then check the buffer sizes passed as argument.
switch (((PC16008DATA)pCoderData)->dwMaxBitRate)
{
case 8000:
if ((*lpSrcBufSize<2*160)||(*lpDstBufSize<MAX_OUTPUT_BYTES_8000_12000))
return (LH_ERRCODE)LH_EBADARG;
*lpSrcBufSize=2*160;
for (i=0;i<160;i++) ((PC16008DATA)pCoderData)->DATA_I[i]=(*input++)>>1; // TEST >>2
#ifdef _X86_
PassLow8(((PC16008DATA)pCoderData)->DATA_I,ivect8,((PC16008DATA)pCoderData)->memBP,160);
iConvert8To64(ivect8,((PC16008DATA)pCoderData)->DATA_I,160,((PC16008DATA)pCoderData)->imem1);
#else
SampleRate8000To6400(((PC16008DATA)pCoderData)->DATA_I,
((PC16008DATA)pCoderData)->DATA_I,
160,
((PC16008DATA)pCoderData)->imem1,
&((PC16008DATA)pCoderData)->uiDelayPosition,
&((PC16008DATA)pCoderData)->iInputStreamTime,
&((PC16008DATA)pCoderData)->iOutputStreamTime );
#endif
break;
case 12000:
if ((*lpSrcBufSize<2*128)||(*lpDstBufSize<MAX_OUTPUT_BYTES_8000_12000))
return (LH_ERRCODE)LH_EBADARG;
*lpSrcBufSize=2*128;
for (i=0;i<128;i++) ((PC16008DATA)pCoderData)->DATA_I[i]=(*input++)>>1; // TEST >>2
break;
case 16000:
if ((*lpSrcBufSize<2*128)||(*lpDstBufSize<MAX_OUTPUT_BYTES_16000))
return (LH_ERRCODE)LH_EBADARG;
*lpSrcBufSize=2*128;
for (i=0;i<128;i++) ((PC16008DATA)pCoderData)->DATA_I[i]=(*input++)>>1; // TEST >>2
break;
}
code_res_I(((PC16008DATA)pCoderData),((PC16008DATA)pCoderData)->DATA_I,coef_I,((PC16008DATA)pCoderData)->QMF_MEM_ANAL_I,((PC16008DATA)pCoderData)->codes_max,
((PC16008DATA)pCoderData)->codes_sb,((PC16008DATA)pCoderData)->indic_sp);
//*#ifdef __VARIABLE__
for (i=NBFAC-1;i>0;i--)
{
((PC16008DATA)pCoderData)->nbbit[i]=((PC16008DATA)pCoderData)->nbbit[i-1]; // on re-adapte les tranches precedentes
}
((PC16008DATA)pCoderData)->nbbit[0]=((PC16008DATA)pCoderData)->nbbit_cf; // valeur pour la tranche actuelle
nbb_ave=0L;
for (i=0;i<NBFAC;i++) nbb_ave+=(long)((PC16008DATA)pCoderData)->nbbit[i];
if (((PC16008DATA)pCoderData)->dwMaxBitRate == 8000)
{
iNBSPF = NBSPF_4800_8000;
iMOD_TH1 = MOD_TH1_8000;
iMOD_TH2 = MOD_TH2_8000;
iMOD_TH3 = MOD_TH3_8000;
iNBSB_SP_MAX1 = NBSB_SP_MAX1_8000_12000;
iNBSB_SP_MAX2 = NBSB_SP_MAX2_8000_12000;
iNBSB_SP_MAX3 = NBSB_SP_MAX3_8000_12000;
iNBSB_SP_MAX4 = NBSB_SP_MAX4_8000_12000;
}
else
{
iNBSPF = NBSPF_12000_16000;
iMOD_TH1 = MOD_TH1_12000_16000;
if (((PC16008DATA)pCoderData)->dwMaxBitRate == 12000)
{
iMOD_TH2 = MOD_TH2_12000;
iMOD_TH3 = MOD_TH3_12000;
iNBSB_SP_MAX1 = NBSB_SP_MAX1_8000_12000;
iNBSB_SP_MAX2 = NBSB_SP_MAX2_8000_12000;
iNBSB_SP_MAX3 = NBSB_SP_MAX3_8000_12000;
iNBSB_SP_MAX4 = NBSB_SP_MAX4_8000_12000;
}
else
{
iMOD_TH2 = MOD_TH2_16000;
iMOD_TH3 = MOD_TH3_16000;
iNBSB_SP_MAX1 = NBSB_SP_MAX1_16000;
iNBSB_SP_MAX2 = NBSB_SP_MAX2_16000;
iNBSB_SP_MAX3 = NBSB_SP_MAX3_16000;
iNBSB_SP_MAX4 = NBSB_SP_MAX4_16000;
}
}
nbb_ave=(short)((nbb_ave*F_ECH)/(NBFAC*iNBSPF));
// On retablit les seuils en fonction de la moyenne calculee
if (nbb_ave<=iMOD_TH1)
{
((PC16008DATA)pCoderData)->MAX_LEVEL = MAX_LEVEL1; // valeur par defaut si le debit n'augmente pas trop
((PC16008DATA)pCoderData)->DIV_MAX = DIV_MAX1; // cad on ne traite pas les sb < 5% du max[i]
((PC16008DATA)pCoderData)->NBSB_SP_MAX = iNBSB_SP_MAX1; // nbre max de sb pouvant etre du signal
}
else
{
if (nbb_ave<=iMOD_TH2) // on a depasse le 1er seuils mais pas le 2eme
{
((PC16008DATA)pCoderData)->MAX_LEVEL = MAX_LEVEL2; // on rejette plus de tranches
((PC16008DATA)pCoderData)->DIV_MAX = DIV_MAX2; // cad on ne traite pas les sb < 7% du max[i]
((PC16008DATA)pCoderData)->NBSB_SP_MAX = iNBSB_SP_MAX2; // nbre max de sb pouvant etre du signal
}
else
{
if (nbb_ave<=iMOD_TH3) // on a depasse le 1er seuils mais pas le 2eme
{
((PC16008DATA)pCoderData)->MAX_LEVEL = MAX_LEVEL3; // on rejette un max
((PC16008DATA)pCoderData)->DIV_MAX = DIV_MAX3; // cad on ne traite pas les sb < 5% du max[i]
((PC16008DATA)pCoderData)->NBSB_SP_MAX = iNBSB_SP_MAX3; // nbre max de sb pouvant etre du signal
}
else // on a depasse le troisieme seuil; il faut descendre!
{
((PC16008DATA)pCoderData)->MAX_LEVEL = MAX_LEVEL4; // meme seuil de rejet
((PC16008DATA)pCoderData)->DIV_MAX = DIV_MAX4; // cad on ne traite pas les sb <10% du max[i]
((PC16008DATA)pCoderData)->NBSB_SP_MAX = iNBSB_SP_MAX4; // nbre max de sb pouvant etre du signal
}
}
}/**/
((PC16008DATA)pCoderData)->stream[0]=0;
for (i=0;i<8;i++)
((PC16008DATA)pCoderData)->stream[0]|=(((PC16008DATA)pCoderData)->indic_sp[i]&0x01)<<i;
numcodes=0;
//temp=bytes[((PC16008DATA)pCoderData)->nbsb_sp];
#if 0
temp=(short)((float)((PC16008DATA)pCoderData)->nbbit_cf/8.0+0.99);
#else
// We want to go away of libcmt, msvcrt... and
// floating point is not really essential here...
if (((PC16008DATA)pCoderData)->nbbit_cf)
temp=(short)((((PC16008DATA)pCoderData)->nbbit_cf-1)/8+1);
else
temp=0;
#endif
for (i=0;i<24;i++) codesizes[i]=0;
for (i=0;i<((PC16008DATA)pCoderData)->nbsb_sp;i++)
{
codes[i]=(long)((PC16008DATA)pCoderData)->codes_max[i];
codes[((PC16008DATA)pCoderData)->nbsb_sp+2*i]=(long)((PC16008DATA)pCoderData)->codes_sb[2*i];
codes[((PC16008DATA)pCoderData)->nbsb_sp+2*i+1]=(long)((PC16008DATA)pCoderData)->codes_sb[2*i+1];
codesizes[i]=5;
codesizes[((PC16008DATA)pCoderData)->nbsb_sp+2*i]=((PC16008DATA)pCoderData)->bits[i]/2;
codesizes[((PC16008DATA)pCoderData)->nbsb_sp+2*i+1]=((PC16008DATA)pCoderData)->bits[i]/2;
numcodes+=3;
}
if (((PC16008DATA)pCoderData)->dwMaxBitRate == 16000)
{
for (i=((PC16008DATA)pCoderData)->nbsb_sp;i<8;i++)
{
codes[2*((PC16008DATA)pCoderData)->nbsb_sp+i]=(long)((PC16008DATA)pCoderData)->codes_max[i];
codes[8+2*i]=(long)((PC16008DATA)pCoderData)->codes_sb[2*i];
codes[8+2*i+1]=(long)((PC16008DATA)pCoderData)->codes_sb[2*i+1];
codesizes[2*((PC16008DATA)pCoderData)->nbsb_sp+i]=5;
codesizes[8+2*i]=SILENCE_CODING_BIT_16000/2;
codesizes[8+2*i+1]=SILENCE_CODING_BIT_16000/2;
numcodes+=3;
}
Multiplexing(((PC16008DATA)pCoderData)->stream+1,codes,codesizes,numcodes,(short)(temp-1));
}
else
if (((PC16008DATA)pCoderData)->nbsb_sp)
Multiplexing(((PC16008DATA)pCoderData)->stream+1,codes,codesizes,numcodes,(short)(temp-1));
*lpDstBufSize=temp;
ptr3 = (unsigned char *)&((PC16008DATA)pCoderData)->stream;
ptr1 = (unsigned char *)lpDstBuf;
for (i =0;i<*lpDstBufSize;i++) ptr1[i] = ptr3[i];
}
return (LH_SUCCESS);
}
// ------------------------------------------------------------------------
LH_PREFIX LH_ERRCODE LH_SUFFIX MSLHSB_Close_Coder(HANDLE hAccess)
{
PVOID pCoderData;
/*short i,flag=0;
// Check if right handle
for (i=0;i<MAXCODINGHANDLES;i++)
if ((CodingHandles[i]==1)&&(hAccess==(HANDLE)&CoderData[i])) {flag=1; break;}
if (flag==0) return LH_BADHANDLE;
// Free handle
CodingHandles[i]=0;*/
if (!hAccess)
return LH_EBADARG;
pCoderData=(PVOID)hAccess;
GlobalFreePtr(pCoderData);
#ifdef __TEST
fclose(codage);
fclose(test);
#endif
return LH_SUCCESS;
}