hvxcpchenc.c

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

		    if(global_pitch != 0.0)
		    {

			if(Ambiguous(prevPrm->pitch, global_pitch, 0.11) ||
			   Ambiguous(prevPrm->pitch, (float) peakPos[0],
				     0.11))
			{
			    if(abs(peakPos[0] - (int) global_pitch) <
			       abs(peakPos[1] - (int) global_pitch))
			    {
				reason = 1;
			    }
			    else
			    {
				reason = 2;
			    }
			}
			else
			{
			    if(abs(peakPos[0] - (int) prevPrm->pitch) <
			       abs(peakPos[1] - (int) prevPrm->pitch))
			    {
				reason = 3;
			    }
			    else
			    {
				reason = 4;
			    }
			}
		    }
		    else
		    {
			if(peak[0] / (peak[1]+EPS) < 1.1)
			{
			    if(abs(peakPos[0] - (int) prevPrm->pitch) <
			       abs(peakPos[1] - (int) prevPrm->pitch))
			    {
				reason = 7;
			    }
			    else
			    {
				reason = 8;
			    }
			}
		    }
		}
		else
		{
		    reason = 9;
		}


		switch(reason)
		{
		case 1:
		case 3:
		case 5:
		case 7:
		case 9:
		    currP = peakPos[0];
		    crntPrm->prob = peak[0] / (peak[1]+EPS);
		    break;
		case 2:
		case 4:
		case 6:
		case 8:
		    currP = peakPos[1];
		    crntPrm->prob = peak[1] / (peak[0]+EPS);
		    break;
		}		    
		crntPrm->pitch = (float) currP;
		crntPrm->r0r = peak[0]/(r0+EPS);
	    }
	    else if (prevPrm->r0r > 0.3)
	    {
		currP = 0;
		for(i=0; i<j; i++)
		{
		    if ((float) peakPos[i] / (prevPrm->pitch+EPS) > 0.75 &&
			(float) peakPos[i] / (prevPrm->pitch+EPS) < 1.3)
		    {
			currP = peakPos[i];
			crntPrm->pitch = (float) currP;
			if(i != 0)
			{
			    crntPrm->prob = peak[i] / (peak[0]+EPS);
			}
			else
			{
			    crntPrm->prob = peak[0] / (peak[1]+EPS);
			}					
			break;
		    }
		}

		if (currP == 0)
		{
		    crntPrm->r0r = 0.0;
		}
		else
		{
		    if (s[currP] / (r0+EPS) < 0.3)
		    {
			if(global_pitch != 0.0)
			{
			    for(i=0; i<j; i++)
			    {
				if((float) peakPos[i] / (global_pitch+EPS)>0.8 &&
				   (float) peakPos[i] / (global_pitch+EPS)<1.2)
				{
				    currP = peakPos[i];	
				    crntPrm->pitch = (float) currP;
				    if(i != 0)
				    {
					crntPrm->prob =
					    peak[i] / (peak[0]+EPS);
				    }
				    else
				    {
					crntPrm->prob =
					    peak[0] / (peak[1]+EPS);
				    }					
				    break;
				}
			    }
			}
		    }	
		}
	    }
	    else
	    {
		if (global_pitch != 0.0)
		{
		    ScanPeakPos(&currP, global_pitch, 0.9, 1.1, j, peakPos,
				peak, s, crntPrm);
		}
	    }
	}
    }
    
    if (r0 < 0.00001)
	crntPrm->r0r = 0.0;
    
    return( currP );
}











static void lpf19(
int	n,
float	*in,
float	*out,
int	cwFlag)
{
    int		i, j;
    float	coef[FILTER_ORDER + 1];
    
    switch(cwFlag)
    {
    case LPF_PI3per4:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = lpfCoefPI3per4[i];
	}
	break;
    case LPF_PIper2:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = lpfCoefPIper2[i];
	}
	break;
    case LPF_PI3per8:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = lpfCoefPI3per8[i];
	}
	break;
    case LPF_PIper4:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = lpfCoefPIper4[i];
	}
	break;
    case LPF_PIper8:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = lpfCoefPIper8[i];
	}
	break;
    }

    for(i=0; i<n; i++)
    {
	out[i] = 0.0;
	for(j = - FILTER_ORDER / 2; j <= FILTER_ORDER / 2; j++)
	{
	    if(i + j >= 0 && i + j < n)
		out[i] += in[i + j] * coef[FILTER_ORDER / 2 - j];  
	}
    }
}

static void hpf19(
int	n,
float	*in,
float	*out,
int	cwFlag)
{
    int		i, j;
    float	coef[FILTER_ORDER + 1];
    
    switch(cwFlag)
    {
    case HPF_PI3per4:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = hpfCoefPI3per4[i];
	}
	break;
    case HPF_PI4per5:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = hpfCoefPI4per5[i];
	}
	break;
    case HPF_PI7per8:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = hpfCoefPI7per8[i];
	}
	break;
    case HPF_PI1per8:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = hpfCoefPI1per8[i];
	}
	break;
    case HPF_PI1per4:
	for(i = 0; i < FILTER_ORDER + 1; i++)
	{
	    coef[i] = hpfCoefPI1per4[i];
	}
	break;
    }

    for(i=0; i<n; i++)
    {
	out[i] = 0.0;
	for(j = - FILTER_ORDER / 2; j <= FILTER_ORDER / 2; j++)
	{
	    if(i + j >= 0 && i + j < n)
		out[i] += in[i + j] * coef[FILTER_ORDER / 2 - j];  
	}
    }
}



static void zero_padding(
int	n1,
int	n2,
float	*s)
{
    int	i;

    for(i=n1; i<n2; i++) s[i] = 0.0;
}

static void z_init(
int	n,
float	*d)
{
    int	i;
    for(i=0; i<n; i++) d[i] = 0.0;
}

static void power(
int	n,
float	*re,
float	*im,
float	*p)
{
    int	i;
    for(i=0; i<n; i++)
    {
	p[i] =  re[i] * re[i] + im[i] * im[i];
    }
}

static void shift_filter_state(
int	n,
float	s[])
{
    int	i;

    for(i=0; i<n-1; i++)
	s[i] = s[i+1];
}

static void shift_ngbPrm(
int	n,
NgbPrm *ngbPrm)
{
    int	i;

    for(i=0; i<n-1; i++)
    {
	ngbPrm[i].pitch = ngbPrm[i + 1].pitch;
	ngbPrm[i].prob = ngbPrm[i + 1].prob;
	ngbPrm[i].r0r = ngbPrm[i + 1].r0r;
	ngbPrm[i].rawR0r = ngbPrm[i + 1].rawR0r;
	ngbPrm[i].rawPitch = ngbPrm[i + 1].rawPitch;
    }
}

static int p_scan(
float	refp,
float	from,
float	to,
int	stop,
int	position_data[],
float	*prevAc)
{
    int	i;
    int	scanp;

    for(i=0,scanp=0; i<stop; i++)
    {
	if ((float) position_data[i] > refp * from &&
	    (float) position_data[i] < refp * to)
	{
	    scanp = position_data[i];
	    break;
	}
    }

    if(prevAc[0]==0.0)
    {
	scanp = 0;
    }
    else if (scanp==0 || prevAc[scanp] / (prevAc[0]+EPS)<0.1)
    {
	scanp = (int)refp;
    }

    return( scanp );
}



static void shift_framePower(
int	n,
float	framePower[])
{
    int	i;
    
    for(i = 0; i < n - 1; i++)
    {
	framePower[i] = framePower[i + 1];
    }
}

static void shift_ac(
float	s[],
float	d[])
{
    int	i;
    for(i=0; i<AL; i++)
	d[i] = s[i];
}


static int levelchk(
int	n,
float	*x)
{
    float	lvl;
    int		i;
    
    for(i=0,lvl=0.0; i<n; i++) lvl += x[i]*x[i];
    
    if(lvl < 4.0 * 4.0 * n)
	return(0);
    else
	return(1);
}


static void GetPitchNFD(
float		*s,
float		*w,
float		lev,
int		filterType,
NgbPrm		*crntPrm,
NgbPrm		*prevPrm,
int		*scanlimit,
PitchPrm	*pchPrm)
{
    float	fdata[AL];
    float	a[ Np+1 ];
    float	residual[AL];
    float	data_r_lpf[AL];
    float	data_i[AL];
    float	eng0, eng1;

    int		fftpow = POWER;
    int		i;

    for(i = 0; i < RSD_SIZE; i++)
    {
	fdata[i] = s[i];
    }

    if(levelchk(RSD_SIZE, fdata))
    {
	lpc2(RSD_SIZE, w, fdata, Np, a);

	get_residual( RSD_SIZE, Np, a, fdata, residual );
	zero_supress( Np, residual );
	
	if(filterType == THROUGH)
	{
	    for(i = 0; i < 256; i++)
	    {
		data_r_lpf[i] = residual[i];
	    }
	}
	else if(filterType >= LPF_OFFSET)
	{
	    hpf19(RSD_SIZE, residual, data_r_lpf, filterType);
	}
	else
	{
	    lpf19(RSD_SIZE, residual, data_r_lpf, filterType);
	}
    }
    else
    {
	z_init(RSD_SIZE, data_r_lpf);
    }
    
    zero_padding(RSD_SIZE, AL, data_r_lpf);

    z_init(AL, data_i);
    
    IPC_fft( data_r_lpf, data_i, fftpow );
    power( AL, data_r_lpf, data_i, pchPrm->ac);
    z_init( AL, data_i );
    IPC_ifft(pchPrm->ac, data_i, fftpow );

    pchPrm->framePower = get_frame_power(data_r_lpf);

    pchPrm->pitch =  (float) getpitch(crntPrm, prevPrm, scanlimit,
				      &(pchPrm->framePower), pchPrm->ac,
				      pchPrm->peakPos, &pchPrm->peak0, lev);

    pchPrm->scanLmt = *scanlimit;

    pchPrm->prob = crntPrm->prob;
    pchPrm->r0r = crntPrm->r0r;

    eng0 = 0.0;
    for(i = 0; i < RSD_SIZE / 2; i++)
    {
	eng0 += (float) s[i] * s[i];
    }

    eng1 = 0.0;
    for(i = RSD_SIZE / 2; i < RSD_SIZE; i++)
    {
	eng1 += (float) s[i] * s[i];
    }

    pchPrm->engRatio = eng0 / (eng1+EPS);

}



static void DecidePitchPrm(
PitchPrm	*pchPrm0,
PitchPrm	*pchPrm1,
int		*scanlimit,
NgbPrm		*crntPrm,
float		*framePower,
float		*peak0,
float		*ac,
int		peakPos[PEAKMAX])
{
    int		i;
    int		reason;

    if((pchPrm0->pitch * 0.96 < pchPrm1->pitch) &&
       (pchPrm1->pitch < pchPrm0->pitch * 1.04))
    {
	reason = 0;
    }	
    else if(pchPrm0->scanLmt > 40)
    {
	reason = 1;
    }	
    else if(pchPrm1->r0r / (pchPrm0->r0r+EPS) > 1.2)
    {
	reason = 2;
    }
    else if(global_pitch != 0.0)
    {
	if(fabs(pchPrm1->pitch - global_pitch) >
	   fabs(pchPrm0->pitch - global_pitch))
	{
	    reason = 3;
	}
	else
	{
	    reason = 4;
	}
    }
    else if(pchPrm0->prob / (pchPrm1->prob+EPS) > 1.2)
    {
	reason = 5;
    }
    else
    {
	reason = 6;
    }	



    switch(reason)
    {
    case 0:
    case 1:
    case 2:
    case 3:
    case 5:
	*scanlimit = pchPrm1->scanLmt;
	crntPrm->pitch = pchPrm1->pitch;
	crntPrm->prob = pchPrm1->prob;
	framePower[1] = pchPrm1->framePower;
	crntPrm->r0r = pchPrm1->r0r;
	peak0[1] = pchPrm1->peak0;

	for(i = 0; i < AL; i++)
	{
	    ac[i] = pchPrm1->ac[i];
	}
	for(i = 0; i < PEAKMAX; i++)
	{
	    peakPos[i] = pchPrm1->peakPos[i];
	}


	break;
    case 4:
	*scanlimit = pchPrm0->scanLmt;
	crntPrm->pitch = pchPrm0->pitch;
	crntPrm->prob = pchPrm0->prob;
	framePower[1] = pchPrm0->framePower;
	crntPrm->r0r = pchPrm0->r0r;
	peak0[1] = pchPrm0->peak0;

	for(i = 0; i < AL; i++)
	{
	    ac[i] = pchPrm0->ac[i];
	}
	for(i = 0; i < PEAKMAX; i++)
	{
	    peakPos[i] = pchPrm0->peakPos[i];
	}

	break;
    }
}


#define PS_FROM		0.81
#define PS_TO		1.2

static float GetStdPch2Elms(
NgbPrm	*ngbPrmCrnt,
NgbPrm	*ngbPrmRef,
int	*scanlimit,
int	peakPos[PEAKMAX],
float	*prevAc)
{
    float	stdPch;

    if((ngbPrmCrnt->r0r >= ngbPrmRef->r0r)
       || ngbPrmCrnt->r0r > 0.7)
    {
	stdPch = ngbPrmCrnt->pitch;
    }
    else
    {
	stdPch = (float) p_scan(ngbPrmRef->pitch, PS_FROM, PS_TO, *scanlimit,
				&peakPos[0], prevAc);
    }

    return(stdPch);
}    

static float TrackingPitch(
NgbPrm	*crntPrm,
NgbPrm	*prevPrm,
int	*scanlimit,
float	*ac,
int	peakPos[PEAKMAX],
int	prevVUV)
{
    float	kimete = 0.0;

    float	pitch;

    static float	prevRawp= 0.0;

    int		st0, st1;

    static float	rblPch = 0.0;

    static float	prevRblPch = 0.0;

    rblPch = global_pitch;

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

	if(!(st0 || st1))
	{
	    if(NearPitch(crntPrm->pitch, prevPrm->pitch, 0.2))
	    {
		pitch = crntPrm->pitch;
	    }
	    else if(NearPitch(crntPrm->pitch, rblPch, 0.2))
	    {
		pitch = crntPrm->pitch;
	    }
	    else if(NearPitch(prevPrm->pitch, rblPch, 0.2))
	    {
		if(crntPrm->r0r > prevPrm->r0r &&
		   crntPrm->prob > prevPrm->prob)
		{
		    pitch = crntPrm->pitch;
		}
		else
		{
		    pitch = prevPrm->pitch;
		}
	    }
	    else
	    {
		pitch = GetStdPch2Elms(crntPrm, prevPrm, scanlimit,
				       peakPos, ac);
	    }
	}
	else if(!st0)
	{
	    if(NearPitch(prevPrm->pitch, crntPrm->pitch, 0.2))
	    {
		pitch = crntPrm->pitch;
	    }
	    else if((gpMax * 1.2 > crntPrm->pitch) &&
		    NearPitch(prevPrm->rawPitch, crntPrm->pitch, 0.2))
	    {
		pitch = crntPrm->pitch;
	    }
	    else
	    {
		pitch = prevPrm->pitch;
	    }		
	}
	else if(!st1)
	{
	    if((crntPrm->rawPitch != crntPrm->pitch) &&
		NearPitch(crntPrm->rawPitch, prevPrm->rawPitch, 0.2))
	    {
		pitch = crntPrm->rawPitch;