hvxcpchenc.c

MPEG2/MPEG4编解码参考程序(实现了MPEG4的部分功能)

	    }
	    else
	    {
		pitch = crntPrm->pitch;
	    }
	    
	}
	else
	{
	    if(NearPitch(prevPrm->pitch, crntPrm->pitch, 0.2))
	    {
		pitch = crntPrm->pitch;
	    }
	    else
	    {
		pitch = rblPch;
	    }
	}
    }
    else if(prevVUV == 0 && rblPch != 0.0)
    {
	st1 = Ambiguous(crntPrm->pitch, rblPch, 0.11);

	if(!st1)
	{
	    pitch = crntPrm->pitch;
	}
	else
	{
	    pitch = rblPch;
	}
    }
    else if(prevVUV != 0 && rblPch == 0.0)
    {
	st1 = Ambiguous(crntPrm->pitch, prevPrm->pitch, 0.11);

	if(!st1)
	{
	    pitch = GetStdPch2Elms(crntPrm, prevPrm, scanlimit, peakPos,
				   ac);
	}
	else
	{
	    if(prevPrm->r0r < crntPrm->r0r)
	    {
		pitch = crntPrm->pitch;
	    }
	    else
	    {
		pitch = prevPrm->pitch;
	    }
	}	    
    }
    else
    {
	pitch = crntPrm->pitch;
    }
    
    
    crntPrm->pitch = pitch;

    prevRblPch = rblPch;

    prevRawp = pitch;

    return(pitch);
}




/* check of music and speech          */
/* return value                       */
/*   0 .... unknown                   */
/*   1 .... music                     */
/*   2 .... speech                    */

#define DEC_PRM 250		/* parameters for decision */
#define DC_CUT

int check_music_speech( float *x, float r0r )
{
    int i, j, k, intflag;
    static int cnt = 0, mvflag = 0;
    static float avdpow, avr0r, sqrpow, sqrr0r;
    float  lvl, avpow, avpow1, dfpow, mavr0r, dfr0r, rms, num;
    static int mutecount=0, sndcount=0;
    static float spow[4], dpow[DEC_PRM];
    static float R0r[DEC_PRM], Avpow[DEC_PRM];
#ifdef DC_CUT
    static float z1=0;
    float y[160];

    for(i=0; i<160; i++) {
	y[i] = x[i+96]-x[i+95]+0.99*z1;
	z1 = y[i];
    }
    for(i=0,lvl=0.0; i<160; i++) lvl += y[i]*y[i];
#else
    for(i=96,lvl=0.0; i<RSD_SIZE; i++) lvl += x[i]*x[i];
#endif

    for (i = 3; i >= 1; i--) spow[i] = spow[i-1];
    spow[0] = lvl/160;

    for(i=0,avpow1=0.0; i<4; i++) avpow1 += spow[i];
    avpow1 /= 4.0;

    avr0r += (r0r-R0r[cnt%DEC_PRM]);
    sqrr0r += (r0r * r0r - R0r[cnt%DEC_PRM] * R0r[cnt%DEC_PRM]);
    R0r[cnt%DEC_PRM] = r0r;
    
    avpow = fabs( spow[0] - avpow1 ) / avpow1;
    avdpow += (avpow - dpow[cnt%DEC_PRM]);
    sqrpow += (avpow * avpow - dpow[cnt%DEC_PRM] * dpow[cnt%DEC_PRM]);
    dpow[cnt%DEC_PRM] = avpow;

    if (avpow1 >= 400) sndcount++;

    if (cnt >= DEC_PRM) {
	num = (float)DEC_PRM;
	avpow = avdpow / num;
	dfpow = sqrpow - num * avpow * avpow;
        dfpow = sqrt( dfpow/num );
	
	mavr0r = avr0r / num;
	dfr0r = sqrr0r - num * mavr0r * mavr0r;
        dfr0r = sqrt( dfr0r/num );

	if (dfr0r <= (0.07 * mavr0r + 0.137))
	    intflag = 1;
        else if (dfr0r >= (0.153 * mavr0r + 0.113))
	    intflag = 2;
        else if (dfpow < (-0.5 * avpow + 0.8))
	    intflag = 1;
        else
	    intflag = 2;

	if (HVXCclassifierMode == 0) {
	    if (Avpow[cnt%DEC_PRM] < 20000) {
	        mutecount = (mutecount == 10) ? 10 : mutecount+1;
            } else {
	        mutecount = 0;
            }
	    if (Avpow[cnt%DEC_PRM] > 400) sndcount--;
        
	    if ((mutecount >= 9 || mvflag == 0) && sndcount >= 0.6*DEC_PRM)
                mvflag = intflag;
	} else {
	    if (Avpow[cnt%DEC_PRM] > 400) sndcount--;
	
	    if (sndcount >= 0.6*DEC_PRM) mvflag = intflag;
	}
    }
    
    Avpow[cnt%DEC_PRM] = avpow1;
    cnt = (cnt == 2*DEC_PRM) ? DEC_PRM : (cnt+1);
    
    return (mvflag);
}





static float GetPitch(
float	*s,
float	*r0r,
float	fb,
float	lev,
float	*w,
int	prevVUV,
float	*r0h)
{
    int		i;
    
    float	ac[ AL ];
    int	scanlimit = Lmax-1;
    int	peakPos[PEAKMAX];

    float	pitchOL;

    PitchPrm	pchPrm0, pchPrm1;

    static NgbPrm	ngbPrm[2] = {{0.0, 0.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0, 0.0}};
    static float	peak0[2];
    static float	framePower[2] = {.0, .0};

    shift_ngbPrm(2, ngbPrm);
    shift_framePower(2, framePower);
    shift_filter_state(2, peak0);

    GetPitchNFD(s, w, lev, HPF_PI1per4, &ngbPrm[1], &ngbPrm[0], &scanlimit,
		&pchPrm0);

    *r0h = ngbPrm[1].rawR0r;

    GetPitchNFD(s, w, lev, LPF_PIper4, &ngbPrm[1], &ngbPrm[0], &scanlimit,
		&pchPrm1);
    judge = check_music_speech( s, ngbPrm[1].rawR0r );

    DecidePitchPrm(&pchPrm0, &pchPrm1, &scanlimit, &ngbPrm[1], framePower,
		   peak0, ac, peakPos);

    ngbPrm[1].rawPitch = peakPos[0];
    
    CheckGlobalPitch(&ngbPrm[1], &ngbPrm[0], lev, peakPos, fb);

    pitchOL = TrackingPitch(&ngbPrm[1], &ngbPrm[0], &scanlimit, ac, peakPos, prevVUV);


    for(i = 0; i < 2; i++)
    {
	r0r[i] = ngbPrm[i].r0r;
    }

    return(pitchOL); 
}


#define BLNUM	32

static void freq_balance(
float rms[],
float arys[],
float *fb,
float *lev)
{
    int i,j;
    float lbl,hbl,level,th;
    float ene[BLNUM],ave,avem,std;
    float pw,peak,pf,av,rmsf;
    short rmss;
    int grn;
    static int stdm=0;
    static int  co=0;
    static float pl=0.;
    float devi,l1devi;

    float	devio, stdo;

    lbl=0.;
    for(i=0; i<SAMPLE/4; i++)
	lbl=lbl+rms[i]*rms[i];
    hbl=0.;
    for(i=SAMPLE/4;i<SAMPLE/2; i++)
	hbl=hbl+rms[i]*rms[i];

    for(i=0;i<BLNUM;i++)
	ene[i]=0.;
    for(i=0;i<BLNUM;i++){
	for(j=0;j<SAMPLE/BLNUM;j++)
	    ene[i] += arys[i*SAMPLE/BLNUM+j]*arys[i*SAMPLE/BLNUM+j];
    }

    for(i=0;i<BLNUM;i++)
	ene[i]=sqrt(ene[i]/(float)(SAMPLE/BLNUM));
    for(i=0,ave=0.0;i<BLNUM;i++)
	ave += ene[i];
    ave=ave/BLNUM;

    avem=1.;
    for(i=0;i<BLNUM;i++){
	if(ene[i] != 0)
	    avem = avem * pow(ene[i], 1./(float)BLNUM);
	else
	    avem = 0.;
    }

    for(i=0,devi=l1devi=0.0;i<BLNUM;i++){
	devi += (ene[i]-ave)*(ene[i]-ave);
	l1devi += fabs(ene[i]-ave);
    }
    devi=sqrt(devi/(float)BLNUM);
    l1devi=(l1devi/(float)BLNUM);
    if(ave>0.001){
	devi=devi/(ave+EPS);
	l1devi=l1devi/(ave+EPS);
    }
    else{
	devi=0.1;
	l1devi=0.1;
    }
    devio=devi;

    if(avem > 0.01)
	std = ave/(avem+EPS);
    else
	std = 1.;
    stdo=std;

    for(i=0,av=0.0;i<SAMPLE;i++)
	av += arys[i];
    av=av/SAMPLE;

    for(i=0,pw=peak=0.0;i<SAMPLE;i++){
	pw += (arys[i]-av)*(arys[i]-av);
	if(fabs(arys[i]-av)>peak) 
	    peak=fabs(arys[i]-av);
    }
    rmsf=sqrt(pw/(float)SAMPLE);
    pf=peak/(rmsf+EPS);

    rmss=(short)rmsf & 0xffff;
    if(rmss <= 7.5)
	grn=1;
    else
	grn=0;

    if(hbl != 0. )
	*fb= lbl/(hbl+EPS) ;
    else
	*fb= 20.;
    if(hbl ==0. && lbl==0.) *fb=0.;

    *lev = level = sqrt((lbl+hbl)/(SAMPLE/2));

    if(level > pl)
	pl = level;

    if(pl >0. && level>0.)
	th=20. * log10(level/(pl+EPS));
    else
	th= -60.;

    if (th <= -60.)
	th= -60.;

    if(devi < 0.4)  
	stdm++;
    else
	stdm=0;

    if(stdm >=5 )
	stdm =5;

    if(grn==1)
	*fb=0;


    else if ((*fb < 5.) && (level < 550.) && (stdm >=1)) {
	*fb=0.;
    }
    else if  ( (level < 550. && devi < 0.45) || (level < 600. && devi < 0.4)) 
	*fb=2.;
    else
	*fb=1.;

    co++;
}

static void modify_fb(
float *fb,
float *lev)
{
    
    float  fbb;
    float  levv;
    static float    threshold=10.;
    static float    fb0=0.;
    static float    fb1=0.;
    static float    fb2=0.;
    static float    fb3=0.;
    static float    fb4=0.;
    static float    fb5=0.;
    
    fbb = *fb;
    levv = *lev;
    
    fb5 = fb4;
    fb4 = fb3;
    fb3 = fb2;
    fb2 = fb1;
    fb1 = fb0;
    fb0 = *fb;  
    
    if( ( fb5+fb4+fb3+fb2+fb1+fb0)==0. )
	threshold = 10.;
    
    if( levv> 500. && threshold !=200.)
	threshold =  90.;

    if( levv>  2000.)
	threshold = 200.;

    if( levv<threshold && fbb!=0 )
	*fb = 0.;
}

static void shift_peak_pos(
int	peak_pos[][PEAKMAX])
{
    int	i;

    for(i=0; i<PEAKMAX; i++){
	peak_pos[0][i] = peak_pos[1][i];
    }
}

static void shift_scanlimit(
int	scl[])
{
    scl[0] = scl[1];
}


static float GetStdPch3Elms(
NgbPrm	*ngbPrm,
int	*scanlimit,
int	(*peak_pos)[PEAKMAX],
float	*prevAc)
{
    float	stdPch;

    if((ngbPrm[1].r0r >= ngbPrm[2].r0r && ngbPrm[1].r0r >= ngbPrm[0].r0r)
       || ngbPrm[1].r0r > 0.7)
    {
	stdPch = ngbPrm[1].pitch;
    }
    else
    {
	if(ngbPrm[0].r0r < ngbPrm[2].r0r)
	{
	    stdPch = (float) p_scan(ngbPrm[2].pitch, PS_FROM, PS_TO,
				    scanlimit[0], &peak_pos[0][0], prevAc);
	}
	else
	{
	    stdPch = (float) p_scan(ngbPrm[0].pitch, PS_FROM, PS_TO,
				    scanlimit[0], &peak_pos[0][0], prevAc);
	}
    }
    return(stdPch);
}    

static float TrackingPitch1FA(
NgbPrm	*ngbPrm,
int	*scanlimit,
float	*ac,
int	(*peak_pos)[PEAKMAX],
float	*prevAc,
int	prevVUV)
{
    float	kimete = 0.0;
    float	pitch;

    static float	prevRawp= 0.0;

    int		st0, st1, st2;

    static float	rblPch = 0.0;

    static float	prevRblPch = 0.0;

    if(prevVUV != 0 && rblPch != 0.0)
    {
	st0 = Ambiguous(ngbPrm[0].pitch, rblPch, 0.11);
	st1 = Ambiguous(ngbPrm[1].pitch, rblPch, 0.11);
	st2 = Ambiguous(ngbPrm[2].pitch, rblPch, 0.11);

	if(!(st0 || st1 || st2))
	{
	    if(Ambiguous(ngbPrm[2].pitch, ngbPrm[1].pitch, 0.11))
	    {
		pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[0], scanlimit,
				       peak_pos[0], prevAc);
	    }		
	    else if(Ambiguous(ngbPrm[0].pitch, ngbPrm[1].pitch, 0.11))
	    {
		pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[2], scanlimit,
				       peak_pos[0], prevAc);
	    }
	    else
	    {
		pitch = GetStdPch3Elms(ngbPrm, scanlimit, peak_pos, prevAc);
	    }
	}
	else if(!(st0 || st1))
	{
	    pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[0], scanlimit,
				   peak_pos[0], prevAc);
	}
	else if(!(st1 || st2))
	{
	    pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[2], scanlimit,
				   peak_pos[0], prevAc);
	}
	else if(!(st2 || st0))
	{
	    pitch = ngbPrm[0].pitch;
	}
	else if(!st0)
	{
	    pitch = ngbPrm[0].pitch;
	}
	else if(!st1)
	{
	    pitch = ngbPrm[1].pitch;
	}
	else if(!st2)
	{
	    pitch = ngbPrm[2].pitch;
	}
	else
	{
	    pitch = rblPch;
	}
    }
    else if(prevVUV == 0 && rblPch != 0.0)
    {
	st1 = Ambiguous(ngbPrm[1].pitch, rblPch, 0.11);
	st2 = Ambiguous(ngbPrm[2].pitch, rblPch, 0.11);

	if(!(st1 || st2))
	{
	    pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[2], scanlimit,
				   peak_pos[0], prevAc);
	}
	else if(!st1)
	{
	    pitch = ngbPrm[1].pitch;
	}
	else if(!st2)
	{
	    pitch = ngbPrm[2].pitch;
	}
	else
	{
	    pitch = rblPch;
	}
    }
    else if(prevVUV != 0 && rblPch == 0.0)
    {
	st0 = Ambiguous(ngbPrm[0].pitch, ngbPrm[2].pitch, 0.11);
	
	if(!st0)
	{
	    pitch = GetStdPch3Elms(ngbPrm, scanlimit, peak_pos, prevAc);
	}
	else
	{
	    pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[0], scanlimit,
				   peak_pos[0], prevAc);
	}
    }
    else
    {
	pitch = GetStdPch2Elms(&ngbPrm[1], &ngbPrm[2], scanlimit, peak_pos[0],
			       prevAc);
    }
    
    
    ngbPrm[1].pitch = pitch;

    rblPch = global_pitch;

    prevRblPch = rblPch;

    prevRawp = pitch;

    return(pitch);
}



static float GetPitch1FA(
float	*s,
float	*r0r,
float	fb,
float	lev,
float	*w,
int	prevVUV,
float	*r0h)
{
    static float	ac[ AL ];
    static float	prev_ac[ AL ];
    
    float	pitchOL;

    int		i;
    
    PitchPrm	pchPrm0, pchPrm1;

    static int	scanlimit[2] = {Lmax-1, Lmax-1};
    static float framePower[3] = {.0, .0, .0};

    static NgbPrm ngbPrm[3] = {{0.0, 0.0, 0.0, 0.0, 0.0},
                                 {0.0, 0.0, 0.0, 0.0, 0.0},
                                 {0.0, 0.0, 0.0, 0.0, 0.0}};

    static int	peak_pos[2][PEAKMAX];
    static float	peak0[3] = {.0, .0, .0};


    shift_ac(ac, prev_ac);

    shift_ngbPrm(3, ngbPrm);
    shift_framePower(3, framePower);
    
    shift_filter_state(3, peak0 );
    shift_scanlimit( scanlimit );
    shift_peak_pos( peak_pos );

    GetPitchNFD(s, w, lev, HPF_PI1per4, &ngbPrm[2], &ngbPrm[1], scanlimit,
		&pchPrm0);

    *r0h = ngbPrm[2].rawR0r;

    GetPitchNFD(s, w, lev, LPF_PIper4, &ngbPrm[2], &ngbPrm[1], scanlimit,
		   &pchPrm1);


    DecidePitchPrm(&pchPrm0, &pchPrm1, scanlimit, ngbPrm, framePower, peak0,
		   ac, peak_pos[1]);

    CheckGlobalPitch(&ngbPrm[2], &ngbPrm[1], lev, peak_pos[1], fb);


    pitchOL = TrackingPitch1FA(ngbPrm, scanlimit, ac, peak_pos, prev_ac, prevVUV);


    for(i = 0; i < 3; i++)
    {
	r0r[i] = ngbPrm[i].r0r;
    }

    return(pitchOL); 
}




void pitch_estimation(
float	*arysRaw,
float	*r0r,
int	idVUV,
float	*pchOL,
float	*r0h)
{
    float	arys[SAMPLE];
    float	aryd[SAMPLE];
    float	ang2[SAMPLE], re2[SAMPLE], im2[SAMPLE], rms2[SAMPLE];

    int		i;

    static float	fb[2] = {0.0, 0.0};
    static float	lev[2] = {0.0, 0.0};
    static int		frm = 0;

    for(i = 0; i < SAMPLE; i++)
    {
	arys[i] = arysRaw[i];
    }

    IPC_hp_filterp(arys, frm);

    IPC_window(ipc_coef, arys, aryd, SAMPLE);
    IPC_fcall_fft(aryd, rms2, ang2, re2, im2);
    
    fb[0] = fb[1];
    lev[0] = lev[1];

    freq_balance(rms2, arys, &fb[1], &lev[1]);

    modify_fb(&fb[0],&lev[0]);

    if(ipc_encDelayMode == DM_LONG)
    {
	*pchOL = GetPitch1FA(arysRaw, r0r, fb[1], lev[1], ipc_coef, idVUV,
			     r0h);
    }
    else
    {
	*pchOL = GetPitch(arysRaw, r0r, fb[1], lev[1], ipc_coef, idVUV, r0h);
    }
    
    if(*pchOL == 0.0)
    {
	*pchOL = (float) (NUMPITCH / 2 + 20);
    }
    
    frm++;

    return;
}