hvxcvxcenc.c

C写的MPEG4音频源代码(G.723/G.729)

    static int	frm = 0;

    if(ipc_encMode == ENC2K)
    {
	blnd = BLND_RATIO_L0_2K;
    }
    else
    {
	blnd = BLND_RATIO_L0_4K;
    }

    SpectralWeightingFilter(alpha, alphaFir);
    PerceptualWeightingFilter(FRM / 2, inVec, alphaFir, inVecW, statePWF);
    ZeroInputResponseSubtraction(alphaFir, qAlpha, stateI, stateAq, 
				 FRM / 2, inVecW, ref);
    
    for(i = 0; i < FRM / 2; i++)
    {
	rvsRef[i] = ref[FRM / 2 - i - 1];
    }

    ZeroStateSynthesis(FRM / 2, rvsRef, synRvsRef, alphaFir, qAlpha);

    for(i = 0; i < FRM / 2; i++)
    {
	synRef[i] = synRvsRef[FRM / 2 - i - 1];
    }

    for(i = 0; i < N_PRE_SEL; i++)
    {
	preSelCb[i].num = 0;
	preSelCb[i].val = 0.0;
    }




    for(i = 0; i < N_SHAPE_L0; i++)
    {
	ip = 0.0;
	for(j = 0; j < FRM / 2; j++)
	{
	    ip += synRef[j] * cb0[i][j];
	}

	if(preSelCb[0].val < ip)
	{
	    preSelCb[0].val = ip;
	    preSelCb[0].num = i;
	    qsort(preSelCb, N_PRE_SEL, sizeof(SelCb), CmpIp);
	}
    }

    ZeroStateSynthesis(FRM / 2, cb0[preSelCb[0].num], synCbS, alphaFir,
		       qAlpha);

    selCb.num = 0;
    if(preSelCb[0].val < 0)
    {
	selCb.val = -1.0 * preSelCb[0].val * preSelCb[0].val;
    }
    else
    {
	selCb.val = preSelCb[0].val * preSelCb[0].val;
    }
    
    
    pwrVec = Power(synCbS, FRM / 2);

    maxIp = preSelCb[0].val;

    for(i = 1; i < N_PRE_SEL; i++)
    {
	ZeroStateSynthesis(FRM / 2, cb0[preSelCb[i].num], synCbS, alphaFir,
			   qAlpha);
	pwr = Power(synCbS, FRM / 2);

	if(preSelCb[i].val < 0)
	{
	    tmp = -1.0 * preSelCb[i].val * preSelCb[i].val;
	}
	else
	{
	    tmp = preSelCb[i].val * preSelCb[i].val;
	}

	if(selCb.val * pwr  < tmp * pwrVec)
	{
	    selCb.num = preSelCb[i].num;
	    selCb.val = tmp;

	    maxIp = preSelCb[i].val;

	    pwrVec = pwr;
	}
    }

    *idS = selCb.num;

    nrmRef = Norm(ref, FRM / 2);

    maxIp = maxIp * (1.0 - blnd) + nrmRef * sqrt(pwrVec) * blnd;
    
    gain = maxIp / pwrVec;
   

    tmp = g0[0] - gain;
    sq = tmp * tmp;
    minSq = sq;
    *idG = 0;
    
    for(i = 1; i < N_GAIN_L0; i++)
    {
	tmp = g0[i] - gain;
	sq = tmp * tmp;
	
	if(sq < minSq)
	{
	    minSq = sq;
	    *idG = i;
	}
    }
   
    for(i = 0; i < FRM / 2; i++) /* appended by Y.Maeda on 98/08/06 */
	qRes[i] = g0[*idG] * cb0[*idS][i];

    VxcSynthesis( qRes, qVec, qAlpha, csflag ); /* appended : end */

    for(i = 0; i < FRM / 2; i++)
    {
	/* qVec[i] = g0[*idG] * synCbS[i]; deleted by Y.Maeda */
	/* qRes[i] = g0[*idG] * cb0[*idS][i]; on 98/08/06     */
	outVec[i] = inVec[i] - qVec[i];
    }
    
    UpdateFilterStates(g0[*idG], cb0[*idS], stateAq, stateI, alphaFir,
		       qAlpha, FRM / 2, ex);

    frm++;
}

static void VqResL0(
float	*ary,
IdCelp	*idCelp,
float	*rawLsp,
float	*qLsp,
int	csflag,
float	*res)
{
    int i, dim;
    
    float inVec[2][FRM/2];
    float qAry[2][FRM/2];
    float qRes[2][FRM/2];
    float outVec[2][FRM/2];


    float	qAlphaIp[2][P + 1], alphaIp[2][P + 1], alphaFir[2][Nfir + 1];
    
    static float	stateI[Nfir + 1], stateAq[P + 1], statePWF[FLTBUF];
    
    static int	frm = 0;

    dim = FRM/2;
    
    if(frm == 0)
    {
	ClearStates(stateAq, stateI, statePWF);
    }
    
    for(i = 0; i < dim; i++)
    {
	inVec[0][i] = ary[i];
	inVec[1][i] = ary[dim + i];
    }
    
    IpLsp2Lpc2(qLsp, qAlphaIp);
    IpLsp2Lpc2(rawLsp, alphaIp);
    
    if(csflag)
    {
	ClearStates(stateAq, stateI, statePWF);
    }
    
    EncSGVQResBF(inVec[0], cb.s, cb.g, qAry[0],
	       qRes[0], alphaIp[0], qAlphaIp[0], alphaFir[0],
	       &(idCelp->idSL0[0]), &(idCelp->idGL0[0]),
	       outVec[0], csflag, stateAq, stateI, statePWF);
	       /* modified by Y.Maeda on 98/08/06 */
    
    EncSGVQResBF(inVec[1], cb.s, cb.g, qAry[1],
	       qRes[1], alphaIp[1], qAlphaIp[1], alphaFir[1],
	       &(idCelp->idSL0[1]), &(idCelp->idGL0[1]),
	       outVec[1], csflag, stateAq, stateI, statePWF);
	       /* modified by Y.Maeda on 98/08/06 */

    for(i=0;i<dim;i++)
    {
	ary[i] = qAry[0][i];
	res[i] = outVec[0][i];
    }
    
    for(i=0;i<dim;i++)
    {
	ary[dim + i] = qAry[1][i];
	res[dim + i] = outVec[1][i];
    }
    frm++;
}

#define N_PRE_SEL_L1	16

static void EncSGVQResBFL1(
float	*inVec,
float	(*cb0)[FRM / 4],
float	*g0,
float	*qVec,
float	*qRes,
float	*alpha,
float	*qAlpha,
float	*alphaFir,
int	*idS,
int	*idG,
float	*outVec,
float	*stateAq,
float	*stateI,
float	*statePWF)
{
    int		i, j;
    float	ip, maxIp;
    float	sq, minSq;
    
    float	inVecW[FRM / 4], synCbS[FRM / 4], ref[FRM / 4];
    float	ex[FRM / 4], rvsRef[FRM / 2], synRvsRef[FRM / 2];
    float	synRef[FRM / 2];
    float	tmp, pwr, nrmRef, nrmInVecW, pwrVec, gain;
    
    SelCb	preSelCb[N_PRE_SEL_L1];
    SelCb	selCb;

    float	blnd;

    static int	frm = 0;

    if(ipc_encMode == ENC2K)
    {
	blnd = BLND_RATIO_L1_2K;
    }
    else
    {
	blnd = BLND_RATIO_L1_4K;
    }

    SpectralWeightingFilter(alpha, alphaFir);
    PerceptualWeightingFilter(FRM / 4, inVec, alphaFir, inVecW, statePWF);
    ZeroInputResponseSubtraction(alphaFir, qAlpha, stateI, stateAq,
				 FRM / 4, inVecW, ref);
    
    nrmInVecW = Norm(inVecW, FRM / 4);

    for(i = 0; i < FRM / 4; i++)
    {
	rvsRef[i] = ref[FRM / 4 - i - 1];
    }

    ZeroStateSynthesis(FRM / 4, rvsRef, synRvsRef, alphaFir, qAlpha);
    
    for(i = 0; i < FRM / 4; i++)
    {
	synRef[i] = synRvsRef[FRM / 4 - i - 1];
    }

    for(i = 0; i < N_PRE_SEL_L1; i++)
    {
	preSelCb[i].num = 0;
	preSelCb[i].val = 0.0;
    }


    for(i = 0; i < N_SHAPE_L1; i++)
    {
	ip = 0.0;
	for(j = 0; j < FRM / 4; j++)
	{
	    ip += synRef[j] * cb0[i][j];
	}

	if(preSelCb[0].val < ip)
	{
	    preSelCb[0].val = ip;
	    preSelCb[0].num = i;
	    qsort(preSelCb, N_PRE_SEL_L1, sizeof(SelCb), CmpIp);
	}
    }

    ZeroStateSynthesis(FRM / 4, cb0[preSelCb[0].num], synCbS, alphaFir,
		       qAlpha);

    selCb.num = 0;
    if(preSelCb[0].val < 0)
    {
	selCb.val = -1.0 * preSelCb[0].val * preSelCb[0].val;
    }
    else
    {
	selCb.val = preSelCb[0].val * preSelCb[0].val;
    }

    pwrVec = Power(synCbS, FRM / 4);

    maxIp = preSelCb[0].val;

    for(i = 1; i < N_PRE_SEL_L1; i++)
    {
	ZeroStateSynthesis(FRM / 4, cb0[preSelCb[i].num], synCbS, alphaFir,
			   qAlpha);
	pwr = Power(synCbS, FRM / 4);

	if(preSelCb[i].val < 0)
	{
	    tmp = -1.0 * preSelCb[i].val * preSelCb[i].val;
	}
	else
	{
	    tmp = preSelCb[i].val * preSelCb[i].val;
	}

	if(selCb.val * pwr < tmp * pwrVec)
	{
	    selCb.num = preSelCb[i].num;
	    selCb.val = tmp;

	    maxIp = preSelCb[i].val;

	    pwrVec = pwr;
	}
    }

    *idS = selCb.num;

    nrmRef = Norm(ref, FRM / 4);

    maxIp = maxIp * (1.0 - blnd) + nrmRef * sqrt(pwrVec) * blnd;
    
    gain = maxIp / pwrVec;

    tmp = g0[0] - gain;
    sq = tmp * tmp;
    minSq = sq;
    *idG = 0;
    
    for(i = 1; i < N_GAIN_L1; i++)
    {
	tmp = g0[i] - gain;
	sq = tmp * tmp;
	
	if(sq < minSq)
	{
	    minSq = sq;
	    *idG = i;
	}
    }
    
    for(i = 0; i < FRM / 4; i++)
    {
	qVec[i] = g0[*idG] * synCbS[i];
	qRes[i] = g0[*idG] * cb0[*idS][i];
	outVec[i] = inVec[i] - qVec[i];
    }
    
    UpdateFilterStates(g0[*idG], cb0[*idS], stateAq, stateI, alphaFir,
		       qAlpha, FRM / 4, ex);

    frm++;
}


static void VqResL1(
float	*ary,
IdCelp	*idCelp,
float	rawLsp[10],
float	qLsp[10],
int	csflag,
float	*res)
{
    int	i, j;
    
    float inVec[4][FRM/4];
    float qAry[4][FRM/4];
    float qRes[4][FRM/4];
    float outVec[4][FRM/4];


    float	qAlphaIp[4][P + 1], alphaIp[4][P + 1], alphaFir[4][Nfir + 1];
    
    static float	stateI[Nfir + 1], stateAq[P + 1], statePWF[FLTBUF];
    
    static int	frm = 0;

    if(frm == 0)
    {
	ClearStates(stateAq, stateI, statePWF);
    }
    
    for(j = 0; j < 4; j++)
    {
	for(i = 0; i < FRM / 4; i++)
	{
	    inVec[j][i] = ary[i + FRM / 4 * j];
	}
    }
    
    IpLsp2Lpc4(qLsp, qAlphaIp);
    IpLsp2Lpc4(rawLsp, alphaIp);
    
    if(csflag)
    {
	ClearStates(stateAq, stateI, statePWF);
    }
    
    for(i = 0; i < 4; i++)
    {
	EncSGVQResBFL1(inVec[i], cbL1.s, cbL1.g, qAry[i],
			qRes[i], alphaIp[i], qAlphaIp[i], alphaFir[i],
			&(idCelp->idSL1[i]), &(idCelp->idGL1[i]),
			outVec[i], stateAq, stateI, statePWF);
    }

    for(j = 0; j < 4; j++)
    {
	for(i = 0; i < FRM / 4; i++)
	{
	    ary[i + j * FRM / 4] = qAry[j][i];
	    res[i + j * FRM / 4] = outVec[j][i];
	}
    }

    frm++;
}







static void QuanUVReasionFBF(
float	arys[FRM],
int	*vuvFlgVXC,
IdCelp	*idCelp,
float	rawLsp[10],
float	qLsp[10])
{
    int i, csflag;
    float ary[3][FRM];

    for(i = 0; i < FRM; i++)
    {
	ary[0][i] = arys[i];
    }


    if(vuvFlgVXC[1] == 0)
    {
	if(vuvFlgVXC[0] != 0)
	{
	    csflag = 1;
	}
	else
	{
	    csflag = 0;
	}

	VqResL0(ary[0], idCelp, rawLsp, qLsp, csflag, ary[1]);

	if(ipc_encMode == ENC4K)
	{
	    VqResL1(ary[1], idCelp, rawLsp, qLsp, csflag, ary[2]);
	}
    }

    return;
}

void td_encoder(
float	arys[FRM],
float	rawLsp[LPCORDER],
float	qLsp[LPCORDER],
int	vuvFlg,
int	*idSL0,
int	*idGL0,
int	*idSL1,
int	*idGL1)
{
    static int	frm = 0;
    int		i;
    static int		vuvFlgVXC[2];

    IdCelp	idCelp;

    vuvFlgVXC[0] = vuvFlgVXC[1];
    vuvFlgVXC[1] = vuvFlg;
    
    QuanUVReasionFBF(arys, vuvFlgVXC, &idCelp, rawLsp, qLsp);

    frm++;

    for(i = 0; i < N_SFRM_L0; i++)
    {
	idSL0[i] = idCelp.idSL0[i];
	idGL0[i] = idCelp.idGL0[i];
    }

    if(ipc_encMode == ENC4K)
    {
	for(i = 0; i < N_SFRM_L1; i++)
	{
	    idSL1[i] = idCelp.idSL1[i];
	    idGL1[i] = idCelp.idGL1[i];
	}
    }
}