/*
 * iLBC - a library for the iLBC codec
 *
 * enhancer.c - The iLBC low bit rate speech codec.
 *
 * Adapted by Steve Underwood <steveu@coppice.org> from the reference
 * iLBC code supplied in RFC3951.
 *
 * Original code Copyright (C) The Internet Society (2004).
 * All changes to produce this version Copyright (C) 2008 by Steve Underwood
 * All Rights Reserved.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * $Id: enhancer.c,v 1.2 2008/03/06 12:27:38 steveu Exp $
 */

/*! \file */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <inttypes.h>
#include <math.h>
#include <string.h>

#include "ilbc.h"
#include "constants.h"
#include "filter.h"
#include "enhancer.h"

/*----------------------------------------------------------------*
 * Find index in array such that the array element with said
 * index is the element of said array closest to "value"
 * according to the squared-error criterion
 *---------------------------------------------------------------*/

static void NearestNeighbor(int *index,            /* (o) index of array element closest to value */
                            const float *array,    /* (i) data array */
                            float value,           /* (i) value */
                            int arlength)          /* (i) dimension of data array */
{
    int i;
    float bestcrit;
    float crit;

    crit = array[0] - value;
    bestcrit = crit*crit;
    *index = 0;
    for (i = 1;  i < arlength;  i++)
    {
        crit = array[i] - value;
        crit = crit*crit;

        if (crit < bestcrit)
        {
            bestcrit= crit;
            *index = i;
        }
    }
}

/*----------------------------------------------------------------*
 * compute cross correlation between sequences
 *---------------------------------------------------------------*/

static void mycorr1(float *corr,       /* (o) correlation of seq1 and seq2 */
                    float *seq1,       /* (i) first sequence */
                    int dim1,          /* (i) dimension first seq1 */
                    const float *seq2, /* (i) second sequence */
                    int dim2)          /* (i) dimension seq2 */
{
    int i;
    int j;

    for (i = 0;  i <= dim1 - dim2;  i++)
    {
        corr[i] = 0.0f;
        for (j = 0;  j < dim2;  j++)
            corr[i] += seq1[i + j]*seq2[j];
    }
}

/*----------------------------------------------------------------*
 * upsample finite array assuming zeros outside bounds
 *---------------------------------------------------------------*/

static void enh_upsample(float *useq1,     /* (o) upsampled output sequence */
                         float *seq1,      /* (i) unupsampled sequence */
                         int dim1,         /* (i) dimension seq1 */
                         int hfl)          /* (i) polyphase filter length=2*hfl+1 */
{
    float *pu;
    float *ps;
    int i;
    int j;
    int k;
    int q;
    int filterlength;
    int hfl2;
    const float *polyp[ENH_UPS0]; /* pointers to polyphase columns */
    const float *pp;

    /* define pointers for filter */

    filterlength = 2*hfl + 1;

    if (filterlength > dim1)
    {
        hfl2 = (int) (dim1/2);
        for (j = 0;  j < ENH_UPS0;  j++)
            polyp[j] = polyphaserTbl + j*filterlength + hfl - hfl2;
        hfl = hfl2;
        filterlength = 2*hfl + 1;
    }
    else
    {
        for (j = 0;  j < ENH_UPS0;  j++)
            polyp[j] = polyphaserTbl+j*filterlength;
    }

    /* filtering: filter overhangs left side of sequence */
    pu = useq1;
    for (i = hfl;  i < filterlength;  i++)
    {
        for (j = 0;  j < ENH_UPS0;  j++)
        {
            *pu = 0.0f;
            pp = polyp[j];
            ps = seq1 + i;
            for (k = 0;  k <= i;  k++)
                *pu += *ps-- * *pp++;
            pu++;
        }
    }

    /* filtering: simple convolution=inner products */
    for (i = filterlength;  i < dim1;  i++)
    {
        for (j = 0;  j < ENH_UPS0;  j++)
        {
            *pu = 0.0f;
            pp = polyp[j];
            ps = seq1 + i;
            for (k = 0;  k < filterlength;  k++)
                *pu += *ps-- * *pp++;
            pu++;
        }
    }

    /* filtering: filter overhangs right side of sequence */
    for (q = 1;  q <= hfl;  q++)
    {
        for (j = 0;  j < ENH_UPS0;  j++)
        {
            *pu = 0.0f;
            pp = polyp[j] + q;
            ps = seq1 + dim1 - 1;
            for (k = 0;  k < filterlength - q;  k++)
                *pu += *ps-- * *pp++;
            pu++;
        }
    }
}

/*----------------------------------------------------------------*
 * find segment starting near idata+estSegPos that has highest
 * correlation with idata+centerStartPos through
 * idata+centerStartPos+ENH_BLOCKL-1 segment is found at a
 * resolution of ENH_UPSO times the original of the original
 * sampling rate
 *---------------------------------------------------------------*/

static void refiner(float *seg,            /* (o) segment array */
                    float *updStartPos,    /* (o) updated start point */
                    float *idata,          /* (i) original data buffer */
                    int idatal,            /* (i) dimension of idata */
                    int centerStartPos,    /* (i) beginning center segment */
                    float estSegPos,       /* (i) estimated beginning other segment */
                    float period)          /* (i) estimated pitch period */
{
    int estSegPosRounded;
    int searchSegStartPos;
    int searchSegEndPos;
    int corrdim;
    int tloc;
    int tloc2;
    int i;
    int st;
    int en;
    int fraction;
    float vect[ENH_VECTL];
    float corrVec[ENH_CORRDIM];
    float maxv;
    float corrVecUps[ENH_CORRDIM*ENH_UPS0];

    period = period;

    /* defining array bounds */
    estSegPosRounded = (int)(estSegPos - 0.5f);

    searchSegStartPos = estSegPosRounded - ENH_SLOP;

    if (searchSegStartPos < 0)
        searchSegStartPos = 0;
    searchSegEndPos = estSegPosRounded + ENH_SLOP;

    if (searchSegEndPos + ENH_BLOCKL >= idatal)
        searchSegEndPos = idatal - ENH_BLOCKL - 1;
    corrdim = searchSegEndPos - searchSegStartPos + 1;

    /* compute upsampled correlation (corr33) and find location of max */
    mycorr1(corrVec, idata + searchSegStartPos, corrdim + ENH_BLOCKL - 1, idata + centerStartPos, ENH_BLOCKL);
    enh_upsample(corrVecUps, corrVec, corrdim, ENH_FL0);
    tloc = 0;
    maxv = corrVecUps[0];
    for (i = 1;  i < ENH_UPS0*corrdim;  i++)
    {
        if (corrVecUps[i]>maxv)
        {
            tloc = i;
            maxv = corrVecUps[i];
        }
    }

    /* make vector can be upsampled without ever running outside bounds */
    *updStartPos = (float) searchSegStartPos + (float) tloc/(float) ENH_UPS0 + 1.0f;
    tloc2 = (int) (tloc/ENH_UPS0);

    if (tloc > tloc2*ENH_UPS0)
        tloc2++;
    st = searchSegStartPos + tloc2 - ENH_FL0;

    if (st < 0)
    {
        memset(vect, 0, -st*sizeof(float));
        memcpy(&vect[-st], idata, (ENH_VECTL + st)*sizeof(float));
    }
    else
    {
        en = st + ENH_VECTL;

        if (en>idatal)
        {
            memcpy(vect, &idata[st], (ENH_VECTL - (en - idatal))*sizeof(float));
            memset(&vect[ENH_VECTL - (en - idatal)], 0, (en - idatal)*sizeof(float));
        }
        else
        {
            memcpy(vect, &idata[st], ENH_VECTL*sizeof(float));
        }
    }
    fraction = tloc2*ENH_UPS0 - tloc;

    /* compute the segment (this is actually a convolution) */
    mycorr1(seg, vect, ENH_VECTL, polyphaserTbl + (2*ENH_FL0 + 1)*fraction, 2*ENH_FL0 + 1);
}

/*----------------------------------------------------------------*
 * find the smoothed output data
 *---------------------------------------------------------------*/

static void smath(float *odata,    /* (o) smoothed output */
                  float *sseq,     /* (i) said second sequence of waveforms */
                  int hl,          /* (i) 2*hl+1 is sseq dimension */
                  float alpha0)    /* (i) max smoothing energy fraction */
{
    int i;
    int k;
    float w00;
    float w10;
    float w11;
    float A;
    float B;
    float C;
    float *psseq;
    float err,errs;
    float surround[ILBC_BLOCK_LEN_MAX]; /* shape contributed by other than current */
    float wt[2*ENH_HL + 1];     /* waveform weighting to get surround shape */
    float denom;

    /* create shape of contribution from all waveforms except the
       current one */

    for (i = 1;  i <= 2*hl + 1;  i++)
        wt[i - 1] = 0.5f*(1.0f - cosf(2.0f*PI*i/(2.0f*hl + 2.0f)));
    wt[hl] = 0.0f; /* for clarity, not used */
    for (i = 0;  i < ENH_BLOCKL;  i++)
        surround[i] = sseq[i]*wt[0];

    for (k = 1;  k < hl;  k++)
    {
        psseq = sseq + k*ENH_BLOCKL;
        for (i = 0;  i < ENH_BLOCKL;  i++)
            surround[i] += psseq[i]*wt[k];
    }
    for (k = hl + 1;  k <= 2*hl;  k++)
    {
        psseq = sseq + k*ENH_BLOCKL;
        for (i = 0;  i < ENH_BLOCKL;  i++)
            surround[i] += psseq[i]*wt[k];
    }

    /* compute some inner products */
    w00 =
    w10 =
    w11 = 0.0f;
    psseq = sseq + hl*ENH_BLOCKL; /* current block  */
    for (i = 0;  i < ENH_BLOCKL;  i++)
    {
        w00 += psseq[i]*psseq[i];
        w11 += surround[i]*surround[i];
        w10 += surround[i]*psseq[i];
    }

    if (fabsf(w11) < 1.0f)
        w11 = 1.0f;
    C = sqrtf(w00/w11);

    /* first try enhancement without power-constraint */
    errs = 0.0f;
    psseq = sseq + hl*ENH_BLOCKL;
    for (i = 0;  i < ENH_BLOCKL;  i++)
    {
        odata[i] = C*surround[i];
        err = psseq[i] - odata[i];
        errs += err*err;
    }

    /* if constraint violated by first try, add constraint */
    if (errs > alpha0 * w00)
    {
        if (w00 < 1)
            w00 = 1;
        denom = (w11*w00 - w10*w10)/(w00*w00);

        if (denom > 0.0001f)
        {
            /* eliminates numerical problems for if smooth */
            A = sqrtf((alpha0 - alpha0*alpha0/4)/denom);
            B = -alpha0/2.0f - A*w10/w00;
            B = B + 1.0f;
        }
        else
        {
            /* essentially no difference between cycles; smoothing not needed */
            A = 0.0f;
            B = 1.0f;
        }

        /* create smoothed sequence */
        psseq = sseq + hl*ENH_BLOCKL;
        for (i = 0;  i < ENH_BLOCKL;  i++)
            odata[i] = A*surround[i] + B*psseq[i];
    }
}

/*----------------------------------------------------------------*
 * get the pitch-synchronous sample sequence
 *---------------------------------------------------------------*/

static void getsseq(float *sseq,           /* (o) the pitch-synchronous sequence */
                    float *idata,          /* (i) original data */
                    int idatal,            /* (i) dimension of data */
                    int centerStartPos,    /* (i) where current block starts */
                    float *period,         /* (i) rough-pitch-period array */
                    const float *plocs,    /* (i) where periods of period array are taken */
                    int periodl,           /* (i) dimension period array */
                    int hl)                /* (i) 2*hl+1 is the number of sequences */
{
    int i;
    int centerEndPos;
    int q;
    float blockStartPos[2*ENH_HL + 1];
    int lagBlock[2*ENH_HL + 1];
    float plocs2[ENH_PLOCSL];
    float *psseq;

    centerEndPos = centerStartPos + ENH_BLOCKL - 1;

    /* present */
    NearestNeighbor(lagBlock + hl,
                    plocs,
                    0.5f*(centerStartPos + centerEndPos),
                    periodl);

    blockStartPos[hl] = (float) centerStartPos;

    psseq = sseq + ENH_BLOCKL*hl;
    memcpy(psseq, idata + centerStartPos, ENH_BLOCKL*sizeof(float));

    /* past */
    for (q = hl - 1;  q >= 0;  q--)
    {
        blockStartPos[q] = blockStartPos[q + 1] - period[lagBlock[q + 1]];
        NearestNeighbor(lagBlock + q,
                        plocs,
                        blockStartPos[q] + ENH_BLOCKL_HALF - period[lagBlock[q + 1]],
                        periodl);

        if (blockStartPos[q] - ENH_OVERHANG >= 0)
        {
            refiner(sseq + q*ENH_BLOCKL,
                    blockStartPos + q,
                    idata,
                    idatal,
                    centerStartPos,
                    blockStartPos[q],
                    period[lagBlock[q + 1]]);
        }
        else
        {
            psseq = sseq + q*ENH_BLOCKL;
            memset(psseq, 0, ENH_BLOCKL*sizeof(float));
        }
    }

    /* future */
    for (i = 0;  i < periodl;  i++)
        plocs2[i] = plocs[i] - period[i];
    for (q = hl + 1;  q <= 2*hl;  q++)
    {
        NearestNeighbor(lagBlock + q, plocs2, blockStartPos[q - 1] + ENH_BLOCKL_HALF, periodl);

        blockStartPos[q] = blockStartPos[q - 1] + period[lagBlock[q]];
        if (blockStartPos[q] + ENH_BLOCKL + ENH_OVERHANG < idatal)
        {
            refiner(sseq + ENH_BLOCKL*q,
                    blockStartPos + q,
                    idata,
                    idatal,
                    centerStartPos,
                    blockStartPos[q],
                    period[lagBlock[q]]);
        }
        else
        {
            psseq = sseq + q*ENH_BLOCKL;
            memset(psseq, 0, ENH_BLOCKL*sizeof(float));
        }
    }
}

/*----------------------------------------------------------------*
 * perform enhancement on idata+centerStartPos through
 * idata+centerStartPos+ENH_BLOCKL-1
 *---------------------------------------------------------------*/

static void enhancer(float *odata,         /* (o) smoothed block, dimension blockl */
                     float *idata,         /* (i) data buffer used for enhancing */
                     int idatal,           /* (i) dimension idata */
                     int centerStartPos,   /* (i) first sample current block within idata */
                     float alpha0,         /* (i) max correction-energy-fraction (in [0,1]) */
                     float *period,        /* (i) pitch period array */
                     const float *plocs,   /* (i) locations where period array values valid */
                     int periodl)          /* (i) dimension of period and plocs */
{
    float sseq[(2*ENH_HL + 1)*ENH_BLOCKL];

    /* get said second sequence of segments */
    getsseq(sseq, idata, idatal, centerStartPos, period, plocs, periodl, ENH_HL);

    /* compute the smoothed output from said second sequence */
    smath(odata, sseq, ENH_HL, alpha0);
}

/*----------------------------------------------------------------*
 * cross correlation
 *---------------------------------------------------------------*/

float xCorrCoef(float *target,      /* (i) first array */
                float *regressor,   /* (i) second array */
                int subl)           /* (i) dimension arrays */
{
    int i;
    float ftmp1;
    float ftmp2;

    ftmp1 = 0.0f;
    ftmp2 = 0.0f;
    for (i = 0;  i < subl;  i++)
    {
        ftmp1 += target[i]*regressor[i];
        ftmp2 += regressor[i]*regressor[i];
    }

    if (ftmp1 > 0.0f)
        return (float)(ftmp1*ftmp1/ftmp2);
    return 0.0f;
}

/*----------------------------------------------------------------*
 * interface for enhancer
 *---------------------------------------------------------------*/

int enhancerInterface(float *out,                         /* (o) enhanced signal */
                      float *in,                          /* (i) unenhanced signal */
                      ilbc_decode_state_t *iLBCdec_inst)  /* (i) buffers etc */
{
    float *enh_buf;
    float *enh_period;
    int iblock;
    int isample;
    int lag = 0;
    int ilag;
    int i;
    int ioffset;
    float cc;
    float maxcc;
    float ftmp1;
    float ftmp2;
    float *inPtr;
    float *enh_bufPtr1;
    float *enh_bufPtr2;
    float plc_pred[ENH_BLOCKL];

    float lpState[6];
    float downsampled[(ENH_NBLOCKS*ENH_BLOCKL + 120)/2];
    int inLen = ENH_NBLOCKS*ENH_BLOCKL + 120;
    int start;
    int plc_blockl;
    int inlag;

    enh_buf = iLBCdec_inst->enh_buf;
    enh_period = iLBCdec_inst->enh_period;

    memmove(enh_buf,
            &enh_buf[iLBCdec_inst->blockl],
            (ENH_BUFL - iLBCdec_inst->blockl)*sizeof(float));

    memcpy(&enh_buf[ENH_BUFL - iLBCdec_inst->blockl],
           in,
           iLBCdec_inst->blockl*sizeof(float));

    if (iLBCdec_inst->mode == 30)
        plc_blockl = ENH_BLOCKL;
    else
        plc_blockl = 40;

    /* when 20 ms frame, move processing one block */
    ioffset = 0;
    if (iLBCdec_inst->mode == 20)
        ioffset = 1;

    i = 3 - ioffset;
    memmove(enh_period, &enh_period[i], (ENH_NBLOCKS_TOT - i)*sizeof(float));

    /* Set state information to the 6 samples right before
       the samples to be downsampled. */

    memcpy(lpState,
           enh_buf + (ENH_NBLOCKS_EXTRA + ioffset)*ENH_BLOCKL - 126,
           6*sizeof(float));

    /* Down sample a factor 2 to save computations */
    DownSample(enh_buf + (ENH_NBLOCKS_EXTRA + ioffset)*ENH_BLOCKL - 120,
               lpFilt_coefsTbl,
               inLen - ioffset*ENH_BLOCKL,
               lpState,
               downsampled);

    /* Estimate the pitch in the down sampled domain. */
    for (iblock = 0; iblock<ENH_NBLOCKS-ioffset; iblock++)
    {
        lag = 10;
        maxcc = xCorrCoef(downsampled + 60 + iblock*ENH_BLOCKL_HALF,
                          downsampled + 60 + iblock*ENH_BLOCKL_HALF - lag,
                          ENH_BLOCKL_HALF);
        for (ilag = 11;  ilag < 60;  ilag++)
        {
            cc = xCorrCoef(downsampled + 60 + iblock*ENH_BLOCKL_HALF,
                           downsampled + 60 + iblock*ENH_BLOCKL_HALF - ilag,
                           ENH_BLOCKL_HALF);
            if (cc > maxcc)
            {
                maxcc = cc;
                lag = ilag;
            }
        }

        /* Store the estimated lag in the non-downsampled domain */
        enh_period[iblock + ENH_NBLOCKS_EXTRA + ioffset] = (float) lag*2.0f;
    }
    /* PLC was performed on the previous packet */
    if (iLBCdec_inst->prev_enh_pl == 1)
    {
        inlag = (int) enh_period[ENH_NBLOCKS_EXTRA + ioffset];

        lag = inlag - 1;
        maxcc = xCorrCoef(in, in + lag, plc_blockl);
        for (ilag = inlag;  ilag <= inlag + 1;  ilag++)
        {
            cc = xCorrCoef(in, in + ilag, plc_blockl);
            if (cc > maxcc)
            {
                maxcc = cc;
                lag = ilag;
            }
        }

        enh_period[ENH_NBLOCKS_EXTRA + ioffset - 1] = (float) lag;

        /* compute new concealed residual for the old lookahead,
           mix the forward PLC with a backward PLC from
           the new frame */

        inPtr = &in[lag - 1];

        enh_bufPtr1 = &plc_pred[plc_blockl - 1];

        if (lag > plc_blockl)
            start = plc_blockl;
        else
            start = lag;

        for (isample = start;  isample > 0;  isample--)
            *enh_bufPtr1-- = *inPtr--;

        enh_bufPtr2=&enh_buf[ENH_BUFL - 1 - iLBCdec_inst->blockl];
        for (isample = (plc_blockl - 1 - lag);  isample >= 0;  isample--)
            *enh_bufPtr1-- = *enh_bufPtr2--;

        /* limit energy change */
        ftmp2 = 0.0f;
        ftmp1 = 0.0f;
        for (i = 0;  i < plc_blockl;  i++)
        {
            ftmp2 += enh_buf[ENH_BUFL - 1 - iLBCdec_inst->blockl - i]*enh_buf[ENH_BUFL - 1 - iLBCdec_inst->blockl - i];
            ftmp1 += plc_pred[i]*plc_pred[i];
        }
        ftmp1 = sqrtf(ftmp1/(float) plc_blockl);
        ftmp2 = sqrtf(ftmp2/(float) plc_blockl);
        if (ftmp1 > 2.0f*ftmp2  &&  ftmp1 > 0.0f)
        {
            for (i = 0;  i < plc_blockl - 10;  i++)
                plc_pred[i] *= 2.0f*ftmp2/ftmp1;
            for (i = plc_blockl - 10;  i < plc_blockl;  i++)
                plc_pred[i]*=(float)(i - plc_blockl + 10)*(1.0f - 2.0f*ftmp2/ftmp1)/10.0f + 2.0f*ftmp2/ftmp1;
        }

        enh_bufPtr1 = &enh_buf[ENH_BUFL - 1 - iLBCdec_inst->blockl];
        for (i = 0;  i < plc_blockl;  i++)
        {
            ftmp1 = (float) (i + 1)/(float) (plc_blockl + 1);
            *enh_bufPtr1 *= ftmp1;
            *enh_bufPtr1 += (1.0f - ftmp1)*plc_pred[plc_blockl - 1 - i];
            enh_bufPtr1--;
        }
    }

    if (iLBCdec_inst->mode == 20)
    {
        /* Enhancer with 40 samples delay */
        for (iblock = 0;  iblock < 2;  iblock++)
        {
            enhancer(out + iblock*ENH_BLOCKL,
                     enh_buf,
                     ENH_BUFL,
                     (5 + iblock)*ENH_BLOCKL + 40,
                     ENH_ALPHA0,
                     enh_period,
                     enh_plocsTbl,
                     ENH_NBLOCKS_TOT);
        }
    }
    else if (iLBCdec_inst->mode == 30)
    {
        /* Enhancer with 80 samples delay */
        for (iblock = 0;  iblock < 3;  iblock++)
        {
            enhancer(out + iblock*ENH_BLOCKL,
                     enh_buf,
                     ENH_BUFL,
                     (4 + iblock)*ENH_BLOCKL,
                     ENH_ALPHA0,
                     enh_period,
                     enh_plocsTbl,
                     ENH_NBLOCKS_TOT);
        }
    }

    return lag*2;
}
