hvxcenc.c

语音压缩算法

float		*mfdpch,
IdAm		*idAm)
{
    int		i, m;
    float	arysres[SAMPLE];
    static float	arys[FRM];

    static float	arysRaw[2][SAMPLE];

    static float	alpha[LPCORDER];
    static float	rawLsp[LPCORDER];
    static float	qLsp[LPCORDER];

    static float	ringBuffer[SAMPLE];

    float	pitchOL;

    float       r0h;

    float	rms[SAMPLE], am[SAMPLE/2][3];

    float       *dumLSF = NULL;
    float	*dummyHarm = NULL;

    int		idAmS[2], idAmG, bitNum;
    int		idAm4k[4];
    int		idCelpSL0[N_SFRM_L0], idCelpGL0[N_SFRM_L0];
    int		idCelpSL1[N_SFRM_L1], idCelpGL1[N_SFRM_L1];

    float	per_wt[129];

    float	frmPwr;

    static float	r0r[3];

    static int	frm = 0;

    static int	normMode = 0;
    static int	offset = -48;

    int		tmpIdVUV;

    static int prevVUV = 0;	/* AI 990322 */

    if(frm == 0)
    {
	for(i = 0; i < FRM; i++)
	{
	    arys[i] = 0.0;
	}

	if(ipc_encDelayMode == DM_LONG)
	{
	    for(i = 0; i < SAMPLE; i++)
	    {
		arysRaw[0][i] = 0.0;
		arysRaw[1][i] = 0.0;
	    }
	}
	else
	{
	    for(i = 0; i < SAMPLE; i++)
	    {
		arysRaw[0][i] = 0.0;
	    }
	}

	for(i = 0; i < SAMPLE; i++)
	{
	    ringBuffer[i] = 0.0;
	}
    }


    if(ipc_encDelayMode == DM_LONG)
    {
	for(m = 0; m < SAMPLE; m++)
	{
	    arysRaw[0][m] = arysRaw[1][m];
	}
    }


    for(i = 0; i < FRM; i++)
    {
	ringBuffer[(frm * FRM + i) % SAMPLE] = (float) frmBuf[i];
    }
    
    if(ipc_encDelayMode == DM_LONG)
    {
	for(m = 0; m < SAMPLE; m++)
	{
	    arysRaw[1][m] =
		ringBuffer[(m + frm * FRM - OVERLAP + SAMPLE) % SAMPLE];
	}
    }
    else
    {
	for(m = 0; m < SAMPLE; m++)
	{
	    arysRaw[0][m] =
		ringBuffer[(m + frm * FRM - OVERLAP + SAMPLE) % SAMPLE];
	}
    }	

    if(ipc_bitstreamMode == BM_VARIABLE)
    {
        if(ipc_encDelayMode == DM_LONG)
        {
#if 1
	    pitch_estimation(arysRaw[1], r0r, prevVUV, &pitchOL, &r0h);	/* AI 990324 */
#else
	    pitch_estimation(arysRaw[1], r0r, *idVUV, &pitchOL, &r0h); 
#endif
        }
        else
        {
#if 1
	    pitch_estimation(arysRaw[0], r0r, prevVUV, &pitchOL, &r0h);	/* AI 990324 */
#else
	    pitch_estimation(arysRaw[0], r0r, *idVUV, &pitchOL, &r0h); 
#endif
        }
        HvxcVUVDecisionVR(arysRaw[0], pitchOL, r0r, r0h, idVUV);
        IPC_NormalizationVR(arysRaw[0], arys, arysres, &frmPwr, alpha, rawLsp,
                          qLsp, idLsp, &offset, *idVUV);

        harm_srew(frmPwr, arysres, 256, offset, pitchOL, mfdpch, am, rms,
	          dummyHarm, &normMode);
    }
    else
    {
        IPC_Normalization(arysRaw[0], arys, arysres, &frmPwr, alpha, rawLsp,
		          qLsp, idLsp, &offset);

        if(ipc_encDelayMode == DM_LONG)
        {
#if 1
	    pitch_estimation(arysRaw[1], r0r, prevVUV, &pitchOL, &r0h);	/* AI 990324 */
#else
	    pitch_estimation(arysRaw[1], r0r, *idVUV, &pitchOL, &r0h); 
#endif
        }
        else
        {
#if 1
	    pitch_estimation(arysRaw[0], r0r, prevVUV, &pitchOL, &r0h);	/* AI 990324 */
#else
	    pitch_estimation(arysRaw[0], r0r, *idVUV, &pitchOL, &r0h);
#endif
        }

        harm_srew(frmPwr, arysres, 256, offset, pitchOL, mfdpch, am, rms,
	          dummyHarm, &normMode);

        vuv_decision(arysRaw[0], mfdpch, am, rms, r0r, idVUV, r0h);
	
    }
    
    prevVUV = *idVUV;	/* AI 990324 */

        td_encoder(arys, rawLsp, qLsp, *idVUV, idCelpSL0, idCelpGL0,
	       idCelpSL1, idCelpGL1);

    for(i = 0; i < 2; i++)
    {
	idCelp->idSL0[i] = idCelpSL0[i];
	idCelp->idGL0[i] = idCelpGL0[i];
    }
    
    if(ipc_encMode == ENC4K)
    {
	for(i = 0; i < N_SFRM_L1; i++)
	{
	    idCelp->idSL1[i] = idCelpSL1[i];
	    idCelp->idGL1[i] = idCelpGL1[i];
	}
    }
    
    percep_weight_alpha(alpha, per_wt);

    if(ipc_bitstreamMode == BM_VARIABLE)
    {
        if(*idVUV == 1)
        {
            tmpIdVUV = 0;
        }
        else
        {
            tmpIdVUV = *idVUV;
        }
        harm_quant(am, mfdpch, per_wt, dumLSF, normMode, tmpIdVUV, idAmS,
	           &bitNum, &idAmG, idAm4k);
    }
    else
    {
        harm_quant(am, mfdpch, per_wt, dumLSF, normMode, *idVUV, idAmS,
	           &bitNum, &idAmG, idAm4k);
    }

    idAm->idS0 = idAmS[0];  
    idAm->idS1 = idAmS[1]; 
    idAm->idG = idAmG;   

    if(ipc_encMode == ENC4K)
    {
	idAm->id4kS0 = idAm4k[0];
	idAm->id4kS1 = idAm4k[1];
	idAm->id4kS2 = idAm4k[2];
	idAm->id4kS3 = idAm4k[3];
    }
    
    frm++;
}


void PackBitsChar(char *encBitChar, int *ptr, int param, int nbit)
{
    int     i;
    
    for(i = 0; i < nbit; i++)
    {
	if(param & (0x01 << (nbit - i - 1)))
	{
	    encBitChar[*ptr] = '1';
	}
	else
	{
	    encBitChar[*ptr] = '0';
	}
	(*ptr)++;
    }
}


static void Prm2Bit(EncPrm *encPrm, unsigned char *encBit)
{
    char	encBitChar[80]; /* for 4kbps one frame */
    int		i, j;
    int		ptr = 0;

    PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[0], 
        PAN_BIT_LSP18_0);
    PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[1], 
        PAN_BIT_LSP18_1);
    PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[2], 
        PAN_BIT_LSP18_2);
    PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[3], 
        PAN_BIT_LSP18_3);
    PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[4], 
        PAN_BIT_LSP18_4);

    PackBitsChar(encBitChar, &ptr, encPrm->vuvFlag, 2);

    if(encPrm->vuvFlag == 0)
    {
	for(i = 0; i < N_SFRM_L0; i++)
	{
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idUV.idSL0[i], 6);
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idUV.idGL0[i], 4);
	}
    }
    else
    {
	PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.pchcode, 7);
	PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idS0, 4);
	PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idS1, 4);
	PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idG, 5);
    }

    for(i = 0; i < 5; i++)
    {
	encBit[i] = 0;
	for(j = 0; j < 8; j++)
	{
	    if(encBitChar[i * 8 + j] == '1')
	    {
		encBit[i] |= 0x01 << (8 - j - 1);
	    }
	}
    }


    if(ipc_encMode == ENC4K)
    {
	PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[5], 8);
	
	if(encPrm->vuvFlag == 0)
	{
	    for(i = 0; i < N_SFRM_L1; i++)
	    {
		PackBitsChar(encBitChar, &ptr,
			     encPrm->vuvPrm.idUV.idSL1[i], 5);
		PackBitsChar(encBitChar, &ptr,
			     encPrm->vuvPrm.idUV.idGL1[i], 3);
	    }
	}
	else
	{
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS0, 7);
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS1, 10);
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS2, 9);
	    PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS3, 6);
	}
	
	for(i = 5; i < 10; i++)
	{
	    encBit[i] = 0;
	    for(j = 0; j < 8; j++)
	    {
		if(encBitChar[i * 8 + j] == '1')
		{
		    encBit[i] |= 0x01 << (8 - j - 1);
		}
	    }
	}
    }
}

static void Prm2BitVR(EncPrm *encPrm, unsigned char *encBit)
{
    char        encBitChar[80]; /* for 4kbps one frame */
    int         i, j;
    int         ptr = 0;

    for(i = 0; i < 80; i++)
    {
        encBitChar[i] = 0;
    }

    PackBitsChar(encBitChar, &ptr, encPrm->vuvFlag, 2);

    if(encPrm->vuvFlag != 1)
    {
        PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[0],
                     PAN_BIT_LSP18_0);
        PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[1],
                     PAN_BIT_LSP18_1);
        PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[2],
                     PAN_BIT_LSP18_2);
        PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[3],
                     PAN_BIT_LSP18_3);
        PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[4],
                     PAN_BIT_LSP18_4);

        if(encPrm->vuvFlag == 0)
        {
            for(i = 0; i < N_SFRM_L0; i++)
            {
                PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idUV.idGL0[i], 4);
            }
        }
        else
        {
            PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.pchcode, 7);
            PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idS0, 4);
            PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idS1, 4);
            PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.idG, 5);
        }
    }

    for(i = 0; i < 5; i++)
    {
        encBit[i] = 0;
        for(j = 0; j < 8; j++)
        {
            if(encBitChar[i * 8 + j] == '1')
            {
                encBit[i] |= 0x01 << (8 - j - 1);
            }
        }
    }


    if(ipc_encMode == ENC4K)
    {
        if(encPrm->vuvFlag != 1)
        {
            PackBitsChar(encBitChar, &ptr, encPrm->idLsp.nVq[5], 8);

            if(encPrm->vuvFlag == 0)
            {
                for(i = 0; i < N_SFRM_L1; i++)
                {
                    PackBitsChar(encBitChar, &ptr,
                                 encPrm->vuvPrm.idUV.idSL1[i], 5);
                    PackBitsChar(encBitChar, &ptr,
                                 encPrm->vuvPrm.idUV.idGL1[i], 3);
                }
            }
            else
            {
                PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS0, 7);
                PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS1, 10);
                PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS2, 9);
                PackBitsChar(encBitChar, &ptr, encPrm->vuvPrm.idV.id4kS3, 6);
            }
        }

        for(i = 5; i < 10; i++)
        {
            encBit[i] = 0;
            for(j = 0; j < 8; j++)
            {
                if(encBitChar[i * 8 + j] == '1')
                {
                    encBit[i] |= 0x01 << (8 - j - 1);
                }
            }
        }
    }
}

void IPC_PackPrm2Bit(
IdLsp		*idLsp,
int		idVUV,
IdCelp		*idCelp,
float		pitch,
IdAm		*idAm,
unsigned char	*encBit)
{
    int		i;

    static int	frm = 0;
    static EncPrm	encPrm;



    for(i = 0; i < L_VQ - 1; i++)
    {
	encPrm.idLsp.nVq[i] = idLsp->nVq[i];
    }
    
    encPrm.vuvFlag = idVUV;


    if(idVUV == 0)
    {
	for(i = 0; i < N_SFRM_L0; i++)
	{
	    encPrm.vuvPrm.idUV.idSL0[i] = idCelp->idSL0[i];
	    encPrm.vuvPrm.idUV.idGL0[i] = idCelp->idGL0[i];
	}
    }
    else
    {
	encPrm.vuvPrm.idV.pchcode = (int) (pitch - 20.0);
	encPrm.vuvPrm.idV.idS0 = idAm->idS0;
	encPrm.vuvPrm.idV.idS1 = idAm->idS1;
	encPrm.vuvPrm.idV.idG = idAm->idG;
    }
    
    if(ipc_encMode == ENC4K)
    {
	encPrm.idLsp.nVq[L_VQ - 1] = idLsp->nVq[L_VQ - 1];
	    
	if(idVUV == 0)
	{
	    for(i = 0; i < N_SFRM_L1; i++)
	    {
		encPrm.vuvPrm.idUV.idSL1[i] = idCelp->idSL1[i];
		encPrm.vuvPrm.idUV.idGL1[i] = idCelp->idGL1[i];
	    }
	}
	else
	{
	    encPrm.vuvPrm.idV.id4kS0 = idAm->id4kS0;
	    encPrm.vuvPrm.idV.id4kS1 = idAm->id4kS1;
	    encPrm.vuvPrm.idV.id4kS2 = idAm->id4kS2;
	    encPrm.vuvPrm.idV.id4kS3 = idAm->id4kS3;
	}
    }

    {
        if(ipc_bitstreamMode == BM_VARIABLE)
        {
	    Prm2BitVR(&encPrm, encBit);
        }
        else
        {
            Prm2Bit(&encPrm, encBit);
        }
    }
    
    frm++;
}