/*#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; }