clids.c

This R2.9 revision of the CLID detector provides the TYPE 1 (on-hook, between first and second ring,

        S32 ac1 = 0;
        for (m = 0; m < 5; m++)
        {
            ac1 += psOut[sOffset + m-2] * (S32)CLID_asShape[m];
        }

        if (psOut[sOffset] > 0)
        {
            uByte |= (1<<k);
            ac0 += ac1;
        }
        else
        {
            ac0 -= ac1;
        }
        sOffset += 5;
    }
    *puByte = uByte;
    return (S16)(ac0 >> 8);
}
/*-------------------------------------------------------------------------*/
void                    clid_cas_bp_filterC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc,
S16 *psIn
)
{
    CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
    S16 *psFrom;
    S16 sIdx = pDb->sCasIdx;
    S16 *psToI;
    S16 *psToQ;
    U16 m;
    S32 ac0;
    S32 ac1;

    S16 k;
    S16 sNormShift = pDb->Cfg.sNormShift;

    /* band-pass data getting */
    for (k = 0; k < CLID_CAS_BP_SSZ; k++)
    {
        pSc->asCasBp[k] = pCasDb->asBpSav[k];
    }
    /* add new data */
    for (k = 0; k < ICLID_FR_SZ; k++)
    {
        S16 x;
        if (sNormShift > 0)
            x = psIn[k] << sNormShift;
        else
            x = psIn[k] >> (-sNormShift);

        pSc->asCasBp[k+CLID_CAS_BP_SSZ] = x;
    }

    psFrom = pSc->asCasBp;
    psToI = pCasDb->asLoI + CLID_CAS_FD_SSZ + sIdx;
    psToQ = pCasDb->asLoQ + CLID_CAS_FD_SSZ + sIdx;
    ac0 = 0;
    ac1 = 0;
    for (m = 0; m < CLID_CAS_BP_ASZ; m++)
    {
        ac0 += *psFrom * (S32)(CLID_asCasLoI[m]);
        ac1 += *psFrom * (S32)(CLID_asCasLoQ[m]);
        psFrom++;
    }
    ac0 += 1<<14; ac0 >>= 15; *psToI = (S16)ac0;
    ac1 += 1<<14; ac1 >>= 15; *psToQ = (S16)ac1;

    psFrom = pSc->asCasBp;
    psToI = pCasDb->asHiI + CLID_CAS_FD_SSZ + sIdx;
    psToQ = pCasDb->asHiQ + CLID_CAS_FD_SSZ + sIdx;
    ac0 = 0;
    ac1 = 0;
    for (m = 0; m < CLID_CAS_BP_ASZ; m++)
    {
        ac0 += *psFrom * (S32)(CLID_asCasHiI[m]);
        ac1 += *psFrom * (S32)(CLID_asCasHiQ[m]);
        psFrom++;
    }
    ac0 += 1<<14; ac0 >>= 15; *psToI = (S16)ac0;
    ac1 += 1<<14; ac1 >>= 15; *psToQ = (S16)ac1;

    /* band-pass data saving*/
    for (k = 0; k < CLID_CAS_BP_SSZ; k++)
    {
        pCasDb->asBpSav[k] = pSc->asBp[k+ICLID_FR_SZ];
    }
}
/*-------------------------------------------------------------------------*/
void 					clid_cas_move_data_inC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
    S16 k;
    /* fd data */
    for (k = 0; k < CLID_CAS_FD_ASZ; k++)
    {
        pSc->asCasLoI[k] = pCasDb->asLoI[k];
        pSc->asCasLoQ[k] = pCasDb->asLoQ[k];
        pSc->asCasHiI[k] = pCasDb->asHiI[k];
        pSc->asCasHiQ[k] = pCasDb->asHiQ[k];
    }
    pDb->uCasReg <<= 1;
}
/*-------------------------------------------------------------------------*/
void                    clid_cas_freqdet_fltC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    S16 k;
    S16 *psFromI = pSc->asCasLoI;
    S16 *psFromQ = pSc->asCasLoQ;
    const S16 *psFlt = CLID_asCasFd;
    S16 *psTo = (S16 *)&pSc->Cas;


    for (k = 0; k < 4; k++)
    {
        S32 ac0 = 0;
        S32 ac1 = 0;
        S16 m;
        for (m = 0; m < CLID_CAS_FD_ASZ; m++)
        {
            ac0 += *psFromI++ * (S32)*psFlt;
            ac1 += *psFromQ++ * (S32)*psFlt;
            psFlt++;
        }
        psFromI -= CLID_CAS_FD_ASZ;
        psFromQ -= CLID_CAS_FD_ASZ;
        ac0 += 1<<14; ac0 >>= 15; *psTo++ = (S16)ac0;
        ac1 += 1<<14; ac1 >>= 15; *psTo++ = (S16)ac1;
    }

    psFromI = pSc->asCasHiI;
    psFromQ = pSc->asCasHiQ;
    for (k = 0; k < 4; k++)
    {
        S32 ac0 = 0;
        S32 ac1 = 0;
        S16 m;
        for (m = 0; m < CLID_CAS_FD_ASZ; m++)
        {
            ac0 += *psFromI++ * (S32)*psFlt;
            ac1 += *psFromQ++ * (S32)*psFlt;
            psFlt++;
        }
        psFromI -= CLID_CAS_FD_ASZ;
        psFromQ -= CLID_CAS_FD_ASZ;
        ac0 += 1<<14; ac0 >>= 15; *psTo++ = (S16)ac0;
        ac1 += 1<<14; ac1 >>= 15; *psTo++ = (S16)ac1;
    }
}
/*-------------------------------------------------------------------------*/
void                    clid_cas_freqdetC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    CLID_tCas *pCas = &pSc->Cas;
    S32 ac0;
    S32 ac1;
    S32 ac2;
    S32 ac3;

    ac0 = pCas->sLoIC1 + pCas->sLoQS1;
    ac1 = pCas->sLoIS1 - pCas->sLoQC1;
    ac2 = ac0 * ac0 + ac1 * ac1;

    ac0 = pCas->sLoIC2 + pCas->sLoQS2;
    ac1 = pCas->sLoIS2 - pCas->sLoQC2;
    ac3 = ac0 * ac0 + ac1 * ac1;

    /* freq */
    ac3 = _en2logC(ac3);
    ac2 = _en2logC(ac2);
    ac0 = ac2 - ac3;
    pCas->sLoFreq = (S16)((ac0 * 8026) >> 15);

    /* energy */
    ac1 = (ac2 + ac3)>>1;
    pCas->sLoEn = (S16)(ac1+_CORR);

    ac0 = pCas->sHiIC1 + pCas->sHiQS1;
    ac1 = pCas->sHiIS1 - pCas->sHiQC1;
    ac2 = ac0 * ac0 + ac1 * ac1;

    ac0 = pCas->sHiIC2 + pCas->sHiQS2;
    ac1 = pCas->sHiIS2 - pCas->sHiQC2;
    ac3 = ac0 * ac0 + ac1 * ac1;

    /* freq */
    ac3 = _en2logC(ac3);
    ac2 = _en2logC(ac2);
    ac0 = ac2 - ac3;
    pCas->sHiFreq = (S16)((ac0 * 6130) >> 15);

    /* energy */
    ac1 = (ac2 + ac3)>>1;
    pCas->sHiEn = (S16)(ac1+_CORR);
}
/*-------------------------------------------------------------------------*/
void 					    clid_cas_testC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    ICLID_tCfg *pCfg = &pDb->Cfg;
    S16 sTest = 0;
    S16 sTmp;

    if (pSc->Cas.sLoEn < pCfg->sMinEn)
    {
        sTest |= CLID_CAS_LO_MIN_EN_MASK;
    }
    if (pSc->Cas.sHiEn < pCfg->sMinEn)
    {
        sTest |= CLID_CAS_HI_MIN_EN_MASK;
    }
    if (pSc->Cas.sLoEn > pCfg->sMaxEn)
    {
        sTest |= CLID_CAS_LO_MAX_EN_MASK;
    }
    if (pSc->Cas.sHiEn > pCfg->sMaxEn)
    {
        sTest |= CLID_CAS_HI_MAX_EN_MASK;
    }
    sTmp = absval(pSc->Cas.sHiEn - pSc->Cas.sLoEn);
    if ( sTmp > pCfg->sMaxTwist)
    {
        sTest |= CLID_CAS_TWIST_MASK;
    }
    sTmp = absval(pSc->Cas.sLoFreq);
    if (sTmp > pCfg->sMaxFreqDev)
    {
        sTest |= CLID_CAS_LO_FREQ_DEV_MASK;
    }
    sTmp = absval(pSc->Cas.sHiFreq);
    if (sTmp > pCfg->sMaxFreqDev)
    {
        sTest |= CLID_CAS_HI_FREQ_DEV_MASK;
    }

    if (sTest == 0)
    {
        pDb->uCasReg |= 1;
    }
    pSc->Cas.sTest = sTest;
}
/*-------------------------------------------------------------------------*/
void 					clid_cas_move_data_outC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    CLID_tCasDb *pCasDb = (CLID_tCasDb *)pDb;
    S16 k;

    /* fd data */
    for (k = 0; k < CLID_CAS_FD_SSZ; k++)
    {
        pCasDb->asLoI[k] = pSc->asCasLoI[k+CLID_CAS_IDX];
        pCasDb->asLoQ[k] = pSc->asCasLoQ[k+CLID_CAS_IDX];
        pCasDb->asHiI[k] = pSc->asCasHiI[k+CLID_CAS_IDX];
        pCasDb->asHiQ[k] = pSc->asCasHiQ[k+CLID_CAS_IDX];
    }
}
/*-------------------------------------------------------------------------*/
void 					clid_move_data_outC
/*-------------------------------------------------------------------------*/
(
CLID_tDb *pDb,
CLID_tSc *pSc
)
{
    S16 k;

    pDb->sCurrBitLen = pSc->sCurrBitLen;
    pDb->sBits = pSc->sBits;
    pDb->sAlignment = pSc->sAlignment;

    /* band-pass data */
    for (k = 0; k < CLID_BPF_SSZ; k++)
    {
        pDb->asBpSav[k] = pSc->asBp[k+ICLID_FR_SZ];
    }
    /* lp data */
    for (k = 0; k < CLID_LPF_SSZ; k++)
    {
        pDb->asLpISav[k] = pSc->asLpI[k+ICLID_FR_SZ];
        pDb->asLpQSav[k] = pSc->asLpQ[k+ICLID_FR_SZ];
    }
    /* mf data */
    for (k = 0; k < CLID_MF_SSZ; k++)
    {
        pDb->asMfISav[k] = pSc->asMfI[k+CLID6_FR_SZ];
        pDb->asMfQSav[k] = pSc->asMfQ[k+CLID6_FR_SZ];
    }
    /* out data */
    for (k = 0; k < CLID_OUT_SSZ; k++)
    {
        pDb->asOutSav[k] = pSc->asOut[k+CLID6_FR_SZ];
    }
}