enhancer.c

视频监控vc源代码.对于做视频系统的朋友们很有帮助

            A= 0.0;
            B= 1.0;
        }
        
        /* create smoothed sequence */

        psseq=sseq+hl*ENH_BLOCKL;
        for (i=0; i<ENH_BLOCKL; i++) {
            odata[i]=A*surround[i]+B*psseq[i];
        }
    }
}

/*----------------------------------------------------------------*
 * get the pitch-synchronous sample sequence
 *---------------------------------------------------------------*/

static void getsseq(
    float *sseq,    /* (o) the pitch-synchronous sequence */
    float *idata,       /* (i) original data */
    int idatal,         /* (i) dimension of data */
    int centerStartPos, /* (i) where current block starts */
    float *period,      /* (i) rough-pitch-period array */


    float *plocs,       /* (i) where periods of period array 
                               are taken */
    int periodl,    /* (i) dimension period array */
    int hl              /* (i) 2*hl+1 is the number of sequences */
){
    int i,centerEndPos,q;
    float blockStartPos[2*ENH_HL+1];
    int lagBlock[2*ENH_HL+1];
    float plocs2[ENH_PLOCSL]; 
    float *psseq;

    centerEndPos=centerStartPos+ENH_BLOCKL-1;
    
    /* present */

    NearestNeighbor(lagBlock+hl,plocs,
        (float)0.5*(centerStartPos+centerEndPos),periodl);
    
    blockStartPos[hl]=(float)centerStartPos;
    psseq=sseq+ENH_BLOCKL*hl;
    memcpy(psseq, idata+centerStartPos, ENH_BLOCKL*sizeof(float));
    
    /* past */

    for (q=hl-1; q>=0; q--) {
        blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]];
        NearestNeighbor(lagBlock+q,plocs,
            blockStartPos[q]+
            ENH_BLOCKL_HALF-period[lagBlock[q+1]], periodl);
                            
        
        if (blockStartPos[q]-ENH_OVERHANG>=0) {
            refiner(sseq+q*ENH_BLOCKL, blockStartPos+q, idata,
                idatal, centerStartPos, blockStartPos[q],
                period[lagBlock[q+1]]);
        } else {
            psseq=sseq+q*ENH_BLOCKL;
            memset(psseq, 0, ENH_BLOCKL*sizeof(float));
        }
    }
    
    /* future */

    for (i=0; i<periodl; i++) {
        plocs2[i]=plocs[i]-period[i];
    }
    for (q=hl+1; q<=2*hl; q++) { 
        NearestNeighbor(lagBlock+q,plocs2,
            blockStartPos[q-1]+ENH_BLOCKL_HALF,periodl);

        blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
        if (blockStartPos[q]+ENH_BLOCKL+ENH_OVERHANG<idatal) {
            refiner(sseq+ENH_BLOCKL*q, blockStartPos+q, idata,
                idatal, centerStartPos, blockStartPos[q],


                period[lagBlock[q]]);
        }
        else {
            psseq=sseq+q*ENH_BLOCKL;
            memset(psseq, 0, ENH_BLOCKL*sizeof(float));
        }
    }
}

/*----------------------------------------------------------------*
 * perform enhancement on idata+centerStartPos through 
 * idata+centerStartPos+ENH_BLOCKL-1
 *---------------------------------------------------------------*/

static void enhancer(
    float *odata,       /* (o) smoothed block, dimension blockl */
    float *idata,       /* (i) data buffer used for enhancing */
    int idatal,         /* (i) dimension idata */
    int centerStartPos, /* (i) first sample current block 
                               within idata */
    float alpha0,       /* (i) max correction-energy-fraction 
                              (in [0,1]) */
    float *period,      /* (i) pitch period array */
    float *plocs,       /* (i) locations where period array 
                               values valid */
    int periodl         /* (i) dimension of period and plocs */
){
    float sseq[(2*ENH_HL+1)*ENH_BLOCKL];

    /* get said second sequence of segments */

    getsseq(sseq,idata,idatal,centerStartPos,period,
        plocs,periodl,ENH_HL);

    /* compute the smoothed output from said second sequence */

    smath(odata,sseq,ENH_HL,alpha0);

}

/*----------------------------------------------------------------*
 * cross correlation
 *---------------------------------------------------------------*/

float xCorrCoef( 
    float *target,      /* (i) first array */
    float *regressor,   /* (i) second array */
    int subl        /* (i) dimension arrays */
){
    int i;
    float ftmp1, ftmp2;
        
    ftmp1 = 0.0;
    ftmp2 = 0.0;


    for (i=0; i<subl; i++) {
        ftmp1 += target[i]*regressor[i];
        ftmp2 += regressor[i]*regressor[i]; 
    }
    
    if (ftmp1 > 0.0) {
        return (float)(ftmp1*ftmp1/ftmp2);
    }
    else {
        return (float)0.0;
    }
}

/*----------------------------------------------------------------*
 * interface for enhancer
 *---------------------------------------------------------------*/

int enhancerInterface(
    float *out,                     /* (o) enhanced signal */
    float *in,                      /* (i) unenhanced signal */
    iLBC_Dec_Inst_t *iLBCdec_inst   /* (i) buffers etc */
){
    float *enh_buf, *enh_period;
    int iblock, isample;
    int lag=0, ilag, i, ioffset;
    float cc, maxcc;
    float ftmp1, ftmp2;
    float *inPtr, *enh_bufPtr1, *enh_bufPtr2;
    float plc_pred[ENH_BLOCKL];

    float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2];
    int inLen=ENH_NBLOCKS*ENH_BLOCKL+120;
    int start, plc_blockl, inlag;

    enh_buf=iLBCdec_inst->enh_buf;
    enh_period=iLBCdec_inst->enh_period;
    
    memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl], 
        (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float));
                                                            
    memcpy(&enh_buf[ENH_BUFL-iLBCdec_inst->blockl], in, 
        iLBCdec_inst->blockl*sizeof(float));

    if (iLBCdec_inst->mode==30)
        plc_blockl=ENH_BLOCKL;
    else
        plc_blockl=40;

    /* when 20 ms frame, move processing one block */
    ioffset=0;
    if (iLBCdec_inst->mode==20) ioffset=1;

    i=3-ioffset;
    memmove(enh_period, &enh_period[i], 


        (ENH_NBLOCKS_TOT-i)*sizeof(float));

    /* Set state information to the 6 samples right before 
       the samples to be downsampled. */

    memcpy(lpState, 
        enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-126, 
        6*sizeof(float));

    /* Down sample a factor 2 to save computations */

    DownSample(enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-120,
                lpFilt_coefsTbl, inLen-ioffset*ENH_BLOCKL,
                lpState, downsampled);

    /* Estimate the pitch in the down sampled domain. */
    for (iblock = 0; iblock<ENH_NBLOCKS-ioffset; iblock++) {
        
        lag = 10;
        maxcc = xCorrCoef(downsampled+60+iblock*
            ENH_BLOCKL_HALF, downsampled+60+iblock*
            ENH_BLOCKL_HALF-lag, ENH_BLOCKL_HALF);
        for (ilag=11; ilag<60; ilag++) {
            cc = xCorrCoef(downsampled+60+iblock*
                ENH_BLOCKL_HALF, downsampled+60+iblock*
                ENH_BLOCKL_HALF-ilag, ENH_BLOCKL_HALF);
            
            if (cc > maxcc) {
                maxcc = cc;
                lag = ilag;
            }
        }

        /* Store the estimated lag in the non-downsampled domain */
        enh_period[iblock+ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2;


    }   


    /* PLC was performed on the previous packet */
    if (iLBCdec_inst->prev_enh_pl==1) {

        inlag=(int)enh_period[ENH_NBLOCKS_EXTRA+ioffset];

        lag = inlag-1;
        maxcc = xCorrCoef(in, in+lag, plc_blockl);
        for (ilag=inlag; ilag<=inlag+1; ilag++) {
            cc = xCorrCoef(in, in+ilag, plc_blockl);
            
            if (cc > maxcc) {
                maxcc = cc;
                lag = ilag;
            }
        }



        enh_period[ENH_NBLOCKS_EXTRA+ioffset-1]=(float)lag;

        /* compute new concealed residual for the old lookahead,
           mix the forward PLC with a backward PLC from 
           the new frame */
        
        inPtr=&in[lag-1];
        
        enh_bufPtr1=&plc_pred[plc_blockl-1];
        
        if (lag>plc_blockl) {
            start=plc_blockl;
        } else {
            start=lag;
        }

        for (isample = start; isample>0; isample--) {
            *enh_bufPtr1-- = *inPtr--;
        }
        
        enh_bufPtr2=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
        for (isample = (plc_blockl-1-lag); isample>=0; isample--) 
{
            *enh_bufPtr1-- = *enh_bufPtr2--;
        }

        /* limit energy change */
        ftmp2=0.0;
        ftmp1=0.0;
        for (i=0;i<plc_blockl;i++) {
            ftmp2+=enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i]*
                enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i];
            ftmp1+=plc_pred[i]*plc_pred[i];
        }
        ftmp1=(float)sqrt(ftmp1/(float)plc_blockl);
        ftmp2=(float)sqrt(ftmp2/(float)plc_blockl);
        if (ftmp1>(float)2.0*ftmp2 && ftmp1>0.0) {
            for (i=0;i<plc_blockl-10;i++) {
                plc_pred[i]*=(float)2.0*ftmp2/ftmp1;
            }
            for (i=plc_blockl-10;i<plc_blockl;i++) {
                plc_pred[i]*=(float)(i-plc_blockl+10)*
                    ((float)1.0-(float)2.0*ftmp2/ftmp1)/(float)(10)+
                    (float)2.0*ftmp2/ftmp1;
            }
        }
    
        enh_bufPtr1=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
        for (i=0; i<plc_blockl; i++) {
            ftmp1 = (float) (i+1) / (float) (plc_blockl+1);
            *enh_bufPtr1 *= ftmp1;
            *enh_bufPtr1 += ((float)1.0-ftmp1)*
                                plc_pred[plc_blockl-1-i];
            enh_bufPtr1--;
        }


    }

    if (iLBCdec_inst->mode==20) {
        /* Enhancer with 40 samples delay */
        for (iblock = 0; iblock<2; iblock++) {
            enhancer(out+iblock*ENH_BLOCKL, enh_buf, 
                ENH_BUFL, (5+iblock)*ENH_BLOCKL+40,
                ENH_ALPHA0, enh_period, enh_plocsTbl, 
                    ENH_NBLOCKS_TOT);
        }
    } else if (iLBCdec_inst->mode==30) {
        /* Enhancer with 80 samples delay */
        for (iblock = 0; iblock<3; iblock++) {
            enhancer(out+iblock*ENH_BLOCKL, enh_buf, 
                ENH_BUFL, (4+iblock)*ENH_BLOCKL,
                ENH_ALPHA0, enh_period, enh_plocsTbl, 
                    ENH_NBLOCKS_TOT);
        }
    }

    return (lag*2);
}