1626 lines
47 KiB
C
1626 lines
47 KiB
C
/*#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 <20> 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 <20> 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;
|
||
}
|
||
|