g723enc.c

嵌入式linux系统的网络编程（C＋＋） 在ARM上实现视频会议 此程序获得全国研究生电子大赛一等奖 压缩包内为全部源码

/* standard library interface */

#include<stdlib.h>
#include<stdio.h>
#include<string.h>

#include"g723enc.h"

//typedef struct _g723enc_obj g723enc_obj;
//typedef struct _Line    Line;
//IppStatus ippstat;

void Encoder_Alloc(int *size)
{
 int tmp;
// printf("Welcome to Encoder_Alloc\n");
 *size=sizeof(g723enc_obj);
 VoiceActivityDetectSize_G723(&tmp);
 *size+=tmp;
}
 
void Init_Cod_Cng(g723enc_obj *g723enc)
{
    int i;
//    printf("Welcome to Init_Cod_Cng\n");
    g723enc->CurGain = 0;
    ippsZero_16s(g723enc->AutoCorr,SizAcf);

    for(i=0; i <= NbAvAcf; i++) g723enc->AutoCorrSfs[i] = 40;
    g723enc->preOlp[0] = sfsize;
    g723enc->preOlp[1] = sfsize;

    ippsZero_16s(g723enc->preSidLpc,lpclen);
    ippsZero_16s(g723enc->RC,lpclen+1);
    ippsZero_16s(g723enc->Ener,NbAvGain);

    g723enc->preFtyp = 1;

    g723enc->CngSeed = 12345;
    g723enc->ShRC = 0;
    g723enc->NbEner = 0;
    g723enc->IRef = 0;
    g723enc->SidGain = 0;
   
    return;
}

void VoiceActivityDetectInit_G723(char* pVADmem)
{
   G723_VADmemory* vadMem =  (G723_VADmemory*)pVADmem;

 //  printf("Welcome to VoiceActivityDetectInit_G723\n");
   vadMem->Hcnt = 3 ;
   vadMem->Vcnt = 0 ;
   vadMem->Penr = 0x400;
   vadMem->Nlev = 0x400 ;

   vadMem->Aen = 0 ;

   vadMem->Polp[0] = 1 ;
   vadMem->Polp[1] = 1 ;

}

void Init_Encoder(g723enc_obj **g723enc)
{
 int i,size;
// printf("Welcome to Init_Encoder\n");
 Encoder_Alloc(&size);
 *g723enc=(g723enc_obj *)malloc(size);
 
 ippsZero_16s((short *)(*g723enc),sizeof(g723enc_obj)>>1);
 (*g723enc)->rate=1;    // low rate is the default rate
 for(i=0;i<5;i++)
   (*g723enc)->preErr[i]=4;
 ippsCopy_16s(LspDcTable,(*g723enc)->preLsp,lpclen);
 (*g723enc)->times=120;
 (*g723enc)->preFtyp=1;
 (*g723enc)->vadMem=(char *)(*g723enc)+sizeof(g723enc_obj);
 VoiceActivityDetectInit_G723((*g723enc)->vadMem);
 Init_Cod_Cng(*g723enc);
// printf("Encoder init over!\n");
} 
 
void Cod_Cng(g723enc_obj *g723enc, short *DataExc, short *Ftyp,Line *line, short *lpc, char rate)
{

    short curQGain;
    short temp;
    short *curCoeff;
    int i;
    short *LspSid;
 //   printf("Welcome to Cod_Cng\n");
   curCoeff=(short *)malloc(lpclen*sizeof(short));
   LspSid=(short *)malloc(lpclen*sizeof(short));
 /* Update Ener */
    for(i=NbAvGain-1; i>=1; i--) {
        g723enc->Ener[i] = g723enc->Ener[i-1];
    }

 /* Compute LPC filter of present frame */
    ippsLevinsonDurbin_G723_16s(g723enc->AutoCorr,&temp,g723enc->Ener,curCoeff);

 /* if first frame of silence => SID frame */
    if(g723enc->preFtyp == 1) {
        *Ftyp = 2;
        g723enc->NbEner = 1;
        QuantSIDGain_G723_16s(g723enc->Ener,g723enc->AutoCorrSfs,g723enc->NbEner,&i);
        curQGain=i;
    }

    else {
        g723enc->NbEner++;
        if(g723enc->NbEner > NbAvGain) g723enc->NbEner = NbAvGain;
        QuantSIDGain_G723_16s(g723enc->Ener,g723enc->AutoCorrSfs,g723enc->NbEner,&i);
        curQGain=i;

        /* Compute stationarity of current filter versus reference filter */
        if(LpcDiff(g723enc->RC,g723enc->ShRC,g723enc->AutoCorr, *g723enc->Ener) == 0) {           
            *Ftyp = 2; /* SID frame */
        }
        else {
            temp = abs(curQGain-g723enc->IRef);
            if(temp > 3) {
                *Ftyp = 2;/* SID frame */
            }
            else {               
                *Ftyp = 0;/* untransmitted */
            }
        }
    }

 
    if(*Ftyp == 2) { /* Compute SID filter */
        short *SidLpc;
	SidLpc=(short *)malloc(lpclen*sizeof(short));
	
        /* Check stationarity */
        ComputePastAvFilter(g723enc,SidLpc) ; /* Past average filter */

        if(!g723enc->Aen)/* adaptation enabled */
           ippsCopy_16s(SidLpc,g723enc->preSidLpc,lpclen); /* update prev SID LPC */
        
        CalcRC(SidLpc , g723enc->RC, &g723enc->ShRC); 

        if(LpcDiff(g723enc->RC, g723enc->ShRC, g723enc->AutoCorr, *g723enc->Ener) == 0){
           ippsCopy_16s(curCoeff,SidLpc,lpclen);
           CalcRC(curCoeff, g723enc->RC, &g723enc->ShRC);
        }

        /* Compute SID frame codes */
        ippsLPCToLSF_G723_16s(SidLpc,g723enc->preLsp,LspSid);

        ippsLSFQuant_G723_16s32s(LspSid,g723enc->preLsp, &line->lspID);
	LSFQuantInv_G723_32s16s(line->lspID,g723enc->preLsp,LspSid,line->Crc);
      
	free(SidLpc);
        line->ampindex[0] = curQGain;
        g723enc->IRef = curQGain;
        DecodeSIDGain_G723_16s(g723enc->IRef,&g723enc->SidGain);

    } 

    /* Compute new excitation */
    if(g723enc->preFtyp == 1) {
        g723enc->CurGain = g723enc->SidGain;
    }
    else {
          g723enc->CurGain = ( (g723enc->CurGain*0xE000)+
                    (g723enc->SidGain*0x2000) )>>16 ;
    }
    {
       char *buf;
       buf=(char *)malloc(ComfortNoiseExcitation_G723_16s_Buff_Size);
       ComfortNoiseExcitation_G723_16s(g723enc->CurGain,g723enc->preExc, DataExc,
                    &g723enc->CngSeed,line->olp,line->closelag,(short *)line->adptgid, rate, buf);
      
       free(buf);
    }
    LspInterpolation_G723(LspSid,g723enc->preLsp,lpc);  
    ippsCopy_16s(LspSid,g723enc->preLsp,lpclen);

    free(curCoeff);
    free(LspSid);
    g723enc->preFtyp = *Ftyp;
    return;
}

void Update_Acf(g723enc_obj *g723enc,short *Acf_sf, const short *ShAcf_sf)
{
    int i, i_subfr;
    short *ptr1, *ptr2;
    const short *ptr3;
    short sh1, temp;
    int L_acc0;
    int L_temp[lpclen+1];
 //   printf("Welcome to Update_Acf\n");
    /* Update Acf and ShAcf */
    ptr2 = g723enc->AutoCorr + SizAcf;                                     // SizAcf=4*11             
    ptr1 = ptr2-(lpclen+1);
    for(i=lpclen+1; i<SizAcf; i++) *(--ptr2) = *(--ptr1);                              // move low 3*11 acf to high 3*11
    for(i=NbAvAcf; i>=1; i--) g723enc->AutoCorrSfs[i] = g723enc->AutoCorrSfs[i-1];    // NbAvAcf=3
                                                      
    /* Search ShAcf_sf min for current frame */
    sh1 = ShAcf_sf[0];
    for(i_subfr=1; i_subfr<4; i_subfr++) {
        if(ShAcf_sf[i_subfr] < sh1) sh1 = ShAcf_sf[i_subfr];                 // find the least ShAcf of a frame
    }
    sh1 += 14;  /* 2 bits of margin */

    /* Compute current sum of acfs */
    for(i=0; i<= lpclen; i++) L_temp[i] = 0;

    ptr3 = Acf_sf;
    for(i_subfr=0; i_subfr<4; i_subfr++) {
        temp = sh1 - ShAcf_sf[i_subfr];
        for(i=0; i <= lpclen; i++) {
            L_acc0 = (int)(*ptr3++);
            if(temp<0) L_acc0 = L_acc0>>(-temp);  /* shift right if temp<0 */
            else L_acc0 = L_acc0<<temp;  
            L_temp[i] += L_acc0;              // L_temp[i]=sum of four real Acf[i]*2^(14+lowest sfs) each access to 29 bits at most
        }
    }
    /* Normalize */
    temp = Exp_32s_Pos(L_temp[0]);        // because AutoCorr[0] is the max value
    temp = 16 - temp;
    if(temp < 0) temp = 0;
    for(i=0; i <= lpclen; i++) {
        g723enc->AutoCorr[i] = (short)(L_temp[i]>>temp);             // Acf is 25 bits value at most Acf[0]
    }
    g723enc->AutoCorrSfs[0] = sh1 - temp;                      // stored acf has left shifted lowest sfs+Exp_32s_Pos(L_temp[0]) bits
    
    return;
}

void CalcRC(short *Coeff, short *RC, short *ShRC)               //calculate relation coefficience stored 0.00a*2^b
{
    int i, j;
    short shift;
    int corr;
 //   printf("Welcome to CalcRC\n");
    corr = 0L;
    for(j=0; j<lpclen; j++) {
        corr = L_mac(corr, Coeff[j], Coeff[j]);
    }
    corr = corr >> 1;
    corr = corr + 0x04000000;                                //0x04000000 for 5-carries-4-discards
    shift = Exp_32s_Pos(corr) - 2;   
    corr = (shift > 0)? ShiftL_32s(corr, shift) : corr >> (-shift); 
    RC[0] = Cnvrt_NR_32s16s(corr);                             //R(0)

    for(i=1; i<=lpclen; i++) {
        corr = (short)0xC000 * Coeff[i-1];   
        for(j=0; j<lpclen-i; j++) {
            corr = L_mac(corr, Coeff[j], Coeff[j+i]);
        }
        corr = (shift > 0)? ShiftL_32s(corr, shift) : corr >> (-shift); 
        RC[i] = Cnvrt_NR_32s16s(corr);                          //RCi=2*R(i)
    }
    *ShRC = shift;
    return;
}

int LpcDiff(short *RC, short ShRC, short *ptrAcf, short alpha)
{
    int L_temp0, L_temp1;
    short temp;
    int i;
    int diff;
//    printf("Welcome to LpcDiff\n");
    L_temp0 = 0L;
    for(i=0; i<=lpclen; i++) {