/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

/*
 * This is the function to merge a new packet with expanded data after a packet loss.
 */

#include "dsp.h"

#include "signal_processing_library.h"

#include "dsp_helpfunctions.h"
#include "neteq_error_codes.h"

/****************************************************************************
 * WebRtcNetEQ_Merge(...)
 *
 * This function...
 *
 * Input:
 *      - inst          : NetEQ DSP instance
 *      - scratchPtr    : Pointer to scratch vector.
 *      - decoded       : Pointer to new decoded speech.
 *      - len           : Number of samples in pw16_decoded.
 *
 *
 * Output:
 *      - inst          : Updated user information
 *      - outData       : Pointer to a memory space where the output data
 *                        should be stored
 *      - pw16_len      : Number of samples written to pw16_outData
 *
 * Return value         :  0 - Ok
 *                        <0 - Error
 */

/* Scratch usage:

 Type           Name                    size            startpos        endpos
 WebRtc_Word16  pw16_expanded           210*fs/8000     0               209*fs/8000
 WebRtc_Word16  pw16_expandedLB         100             210*fs/8000     99+210*fs/8000
 WebRtc_Word16  pw16_decodedLB          40              100+210*fs/8000 139+210*fs/8000
 WebRtc_Word32  pw32_corr               2*60            140+210*fs/8000 260+210*fs/8000
 WebRtc_Word16  pw16_corrVec            68              210*fs/8000     67+210*fs/8000

 [gap in scratch vector]

 func           WebRtcNetEQ_Expand      40+370*fs/8000  126*fs/8000     39+496*fs/8000

 Total:  40+496*fs/8000
 */

#define SCRATCH_pw16_expanded          0
#if (defined(NETEQ_48KHZ_WIDEBAND)) 
#define SCRATCH_pw16_expandedLB        1260
#define SCRATCH_pw16_decodedLB         1360
#define SCRATCH_pw32_corr              1400
#define SCRATCH_pw16_corrVec           1260
#define SCRATCH_NETEQ_EXPAND            756
#elif (defined(NETEQ_32KHZ_WIDEBAND)) 
#define SCRATCH_pw16_expandedLB        840
#define SCRATCH_pw16_decodedLB         940
#define SCRATCH_pw32_corr              980
#define SCRATCH_pw16_corrVec           840
#define SCRATCH_NETEQ_EXPAND            504
#elif (defined(NETEQ_WIDEBAND)) 
#define SCRATCH_pw16_expandedLB        420
#define SCRATCH_pw16_decodedLB         520
#define SCRATCH_pw32_corr              560
#define SCRATCH_pw16_corrVec           420
#define SCRATCH_NETEQ_EXPAND            252
#else    /* NB */
#define SCRATCH_pw16_expandedLB        210
#define SCRATCH_pw16_decodedLB         310
#define SCRATCH_pw32_corr              350
#define SCRATCH_pw16_corrVec           210
#define SCRATCH_NETEQ_EXPAND            126
#endif

int WebRtcNetEQ_Merge(DSPInst_t *inst,
#ifdef SCRATCH
                      WebRtc_Word16 *pw16_scratchPtr,
#endif
                      WebRtc_Word16 *pw16_decoded, int len, WebRtc_Word16 *pw16_outData,
                      WebRtc_Word16 *pw16_len)
{

    WebRtc_Word16 fs_mult;
    WebRtc_Word16 fs_shift;
    WebRtc_Word32 w32_En_new_frame, w32_En_old_frame;
    WebRtc_Word16 w16_expmax, w16_newmax;
    WebRtc_Word16 w16_tmp, w16_tmp2;
    WebRtc_Word32 w32_tmp;
#ifdef SCRATCH
    WebRtc_Word16 *pw16_expanded = pw16_scratchPtr + SCRATCH_pw16_expanded;
    WebRtc_Word16 *pw16_expandedLB = pw16_scratchPtr + SCRATCH_pw16_expandedLB;
    WebRtc_Word16 *pw16_decodedLB = pw16_scratchPtr + SCRATCH_pw16_decodedLB;
    WebRtc_Word32 *pw32_corr = (WebRtc_Word32*) (pw16_scratchPtr + SCRATCH_pw32_corr);
    WebRtc_Word16 *pw16_corrVec = pw16_scratchPtr + SCRATCH_pw16_corrVec;
#else
    WebRtc_Word16 pw16_expanded[(125+80+5)*FSMULT];
    WebRtc_Word16 pw16_expandedLB[100];
    WebRtc_Word16 pw16_decodedLB[40];
    WebRtc_Word32 pw32_corr[60];
    WebRtc_Word16 pw16_corrVec[4+60+4];
#endif
    WebRtc_Word16 *pw16_corr = &pw16_corrVec[4];
    WebRtc_Word16 w16_stopPos, w16_bestIndex, w16_interpLen;
    WebRtc_Word16 w16_bestVal; /* bestVal is dummy */
    WebRtc_Word16 w16_startfact, w16_inc;
    WebRtc_Word16 w16_expandedLen;
    WebRtc_Word16 w16_startPos;
    WebRtc_Word16 w16_expLen, w16_newLen = 0;
    WebRtc_Word16 *pw16_decodedOut;
    WebRtc_Word16 w16_muted;

    int w16_decodedLen = len;

#ifdef NETEQ_STEREO
    MasterSlaveInfo *msInfo = inst->msInfo;
#endif

    fs_mult = WebRtcSpl_DivW32W16ResW16(inst->fs, 8000);
    fs_shift = 30 - WebRtcSpl_NormW32(fs_mult); /* Note that this is not "exact" for 48kHz */

    /*************************************
     * Generate data to merge with
     *************************************/
    /*
     * Check how much data that is left since earlier
     * (at least there should be the overlap)...
     */
    w16_startPos = inst->endPosition - inst->curPosition;
    /* Get one extra expansion to merge and overlap with */
    inst->ExpandInst.w16_stopMuting = 1;
    inst->ExpandInst.w16_lagsDirection = 1; /* make sure we get the "optimal" lag */
    inst->ExpandInst.w16_lagsPosition = -1; /* out of the 3 possible ones */
    w16_expandedLen = 0; /* Does not fill any function currently */

    if (w16_startPos >= 210 * FSMULT)
    {
        /*
         * The number of samples available in the sync buffer is more than what fits in
         * pw16_expanded.Keep the first 210*FSMULT samples, but shift them towards the end of
         * the buffer. This is ok, since all of the buffer will be expand data anyway, so as
         * long as the beginning is left untouched, we're fine.
         */

        w16_tmp = w16_startPos - 210 * FSMULT; /* length difference */

        WEBRTC_SPL_MEMMOVE_W16(&inst->speechBuffer[inst->curPosition+w16_tmp] ,
                               &inst->speechBuffer[inst->curPosition], 210*FSMULT);

        inst->curPosition += w16_tmp; /* move start position of sync buffer accordingly */
        w16_startPos = 210 * FSMULT; /* this is the truncated length */
    }

    WebRtcNetEQ_Expand(inst,
#ifdef SCRATCH
        pw16_scratchPtr + SCRATCH_NETEQ_EXPAND,
#endif
        pw16_expanded, /* let Expand write to beginning of pw16_expanded to avoid overflow */
        &w16_newLen, 0);

    /*
     * Now shift the data in pw16_expanded to where it belongs.
     * Truncate all that ends up outside the vector.
     */

    WEBRTC_SPL_MEMMOVE_W16(&pw16_expanded[w16_startPos], pw16_expanded,
                           WEBRTC_SPL_MIN(w16_newLen,
                               WEBRTC_SPL_MAX(210*FSMULT - w16_startPos, 0) ) );

    inst->ExpandInst.w16_stopMuting = 0;

    /* Copy what is left since earlier into the expanded vector */

    WEBRTC_SPL_MEMCPY_W16(pw16_expanded, &inst->speechBuffer[inst->curPosition], w16_startPos);

    /*
     * Do "ugly" copy and paste from the expanded in order to generate more data
     * to correlate (but not interpolate) with.
     */
    w16_expandedLen = (120 + 80 + 2) * fs_mult;
    w16_expLen = w16_startPos + w16_newLen;

    if (w16_expLen < w16_expandedLen)
    {
        while ((w16_expLen + w16_newLen) < w16_expandedLen)
        {
            WEBRTC_SPL_MEMCPY_W16(&pw16_expanded[w16_expLen], &pw16_expanded[w16_startPos],
                w16_newLen);
            w16_expLen += w16_newLen;
        }

        /* Copy last part (fraction of a whole expansion) */

        WEBRTC_SPL_MEMCPY_W16(&pw16_expanded[w16_expLen], &pw16_expanded[w16_startPos],
                              (w16_expandedLen-w16_expLen));
    }
    w16_expLen = w16_expandedLen;

    /* Adjust muting factor (main muting factor times expand muting factor) */
    inst->w16_muteFactor
        = (WebRtc_Word16) WEBRTC_SPL_MUL_16_16_RSFT(inst->w16_muteFactor,
            inst->ExpandInst.w16_expandMuteFactor, 14);

    /* Adjust muting factor if new vector is more or less of the BGN energy */
    len = WEBRTC_SPL_MIN(64*fs_mult, w16_decodedLen);
    w16_expmax = WebRtcSpl_MaxAbsValueW16(pw16_expanded, (WebRtc_Word16) len);
    w16_newmax = WebRtcSpl_MaxAbsValueW16(pw16_decoded, (WebRtc_Word16) len);

    /* Calculate energy of old data */
    w16_tmp = 6 + fs_shift - WebRtcSpl_NormW32(WEBRTC_SPL_MUL_16_16(w16_expmax, w16_expmax));
    w16_tmp = WEBRTC_SPL_MAX(w16_tmp,0);
    w32_En_old_frame = WebRtcNetEQ_DotW16W16(pw16_expanded, pw16_expanded, len, w16_tmp);

    /* Calculate energy of new data */
    w16_tmp2 = 6 + fs_shift - WebRtcSpl_NormW32(WEBRTC_SPL_MUL_16_16(w16_newmax, w16_newmax));
    w16_tmp2 = WEBRTC_SPL_MAX(w16_tmp2,0);
    w32_En_new_frame = WebRtcNetEQ_DotW16W16(pw16_decoded, pw16_decoded, len, w16_tmp2);

    /* Align to same Q-domain */
    if (w16_tmp2 > w16_tmp)
    {
        w32_En_old_frame = WEBRTC_SPL_RSHIFT_W32(w32_En_old_frame, (w16_tmp2-w16_tmp));
    }
    else
    {
        w32_En_new_frame = WEBRTC_SPL_RSHIFT_W32(w32_En_new_frame, (w16_tmp-w16_tmp2));
    }

    /* Calculate muting factor to use for new frame */
    if (w32_En_new_frame > w32_En_old_frame)
    {
        /* Normalize w32_En_new_frame to 14 bits */
        w16_tmp = WebRtcSpl_NormW32(w32_En_new_frame) - 17;
        w32_En_new_frame = WEBRTC_SPL_SHIFT_W32(w32_En_new_frame, w16_tmp);

        /*
         * Put w32_En_old_frame in a domain 14 higher, so that
         * w32_En_old_frame/w32_En_new_frame is in Q14
         */
        w16_tmp = w16_tmp + 14;
        w32_En_old_frame = WEBRTC_SPL_SHIFT_W32(w32_En_old_frame, w16_tmp);
        w16_tmp
            = WebRtcSpl_DivW32W16ResW16(w32_En_old_frame, (WebRtc_Word16) w32_En_new_frame);
        /* Calculate sqrt(w32_En_old_frame/w32_En_new_frame) in Q14 */
        w16_muted = (WebRtc_Word16) WebRtcSpl_SqrtFloor(
            WEBRTC_SPL_LSHIFT_W32((WebRtc_Word32)w16_tmp,14));
    }
    else
    {
        w16_muted = 16384; /* Set = 1.0 when old frame has higher energy than new */
    }

    /* Set the raise the continued muting factor w16_muted if w16_muteFactor is lower */
    if (w16_muted > inst->w16_muteFactor)
    {
        inst->w16_muteFactor = WEBRTC_SPL_MIN(w16_muted, 16384);
    }

#ifdef NETEQ_STEREO

    /* Sanity for msInfo */
    if (msInfo == NULL)
    {
        /* this should not happen here */
        return MASTER_SLAVE_ERROR;
    }

    /* do not downsample and calculate correlations for slave instance(s) */
    if ((msInfo->msMode == NETEQ_MASTER) || (msInfo->msMode == NETEQ_MONO))
    {
#endif

        /*********************************************
         * Downsample to 4kHz and find best overlap
         *********************************************/

        /* Downsample to 4 kHz */
        if (inst->fs == 8000)
        {
            WebRtcSpl_DownsampleFast(&pw16_expanded[2], (WebRtc_Word16) (w16_expandedLen - 2),
                pw16_expandedLB, (WebRtc_Word16) (100),
                (WebRtc_Word16*) WebRtcNetEQ_kDownsample8kHzTbl, (WebRtc_Word16) 3,
                (WebRtc_Word16) 2, (WebRtc_Word16) 0);
            if (w16_decodedLen <= 80)
            {
                /* Not quite long enough, so we have to cheat a bit... */
                WebRtc_Word16 temp_len = w16_decodedLen - 2;
                w16_tmp = temp_len / 2;
                WebRtcSpl_DownsampleFast(&pw16_decoded[2], temp_len,
                                         pw16_decodedLB, w16_tmp,
                                         (WebRtc_Word16*) WebRtcNetEQ_kDownsample8kHzTbl,
                    (WebRtc_Word16) 3, (WebRtc_Word16) 2, (WebRtc_Word16) 0);
                WebRtcSpl_MemSetW16(&pw16_decodedLB[w16_tmp], 0, (40 - w16_tmp));
            }
            else
            {
                WebRtcSpl_DownsampleFast(&pw16_decoded[2],
                    (WebRtc_Word16) (w16_decodedLen - 2), pw16_decodedLB,
                    (WebRtc_Word16) (40), (WebRtc_Word16*) WebRtcNetEQ_kDownsample8kHzTbl,
                    (WebRtc_Word16) 3, (WebRtc_Word16) 2, (WebRtc_Word16) 0);
            }
#ifdef NETEQ_WIDEBAND
        }
        else if (inst->fs==16000)
        {
            WebRtcSpl_DownsampleFast(
                &pw16_expanded[4], (WebRtc_Word16)(w16_expandedLen-4),
                pw16_expandedLB, (WebRtc_Word16)(100),
                (WebRtc_Word16*)WebRtcNetEQ_kDownsample16kHzTbl, (WebRtc_Word16)5,
                (WebRtc_Word16)4, (WebRtc_Word16)0);
            if (w16_decodedLen<=160)
            {
                /* Not quite long enough, so we have to cheat a bit... */
                WebRtc_Word16 temp_len = w16_decodedLen - 4;
                w16_tmp = temp_len / 4;
                WebRtcSpl_DownsampleFast(
                    &pw16_decoded[4], temp_len,
                    pw16_decodedLB, w16_tmp,
                    (WebRtc_Word16*)WebRtcNetEQ_kDownsample16kHzTbl, (WebRtc_Word16)5,
                    (WebRtc_Word16)4, (WebRtc_Word16)0);
                WebRtcSpl_MemSetW16(&pw16_decodedLB[w16_tmp], 0, (40-w16_tmp));
            }
            else
            {
                WebRtcSpl_DownsampleFast(
                    &pw16_decoded[4], (WebRtc_Word16)(w16_decodedLen-4),
                    pw16_decodedLB, (WebRtc_Word16)(40),
                    (WebRtc_Word16*)WebRtcNetEQ_kDownsample16kHzTbl, (WebRtc_Word16)5,
                    (WebRtc_Word16)4, (WebRtc_Word16)0);
            }
#endif
#ifdef NETEQ_32KHZ_WIDEBAND
        }
        else if (inst->fs==32000)
        {
            /*
             * TODO(hlundin) Why is the offset into pw16_expanded 6?
             */
            WebRtcSpl_DownsampleFast(
                &pw16_expanded[6], (WebRtc_Word16)(w16_expandedLen-6),
                pw16_expandedLB, (WebRtc_Word16)(100),
                (WebRtc_Word16*)WebRtcNetEQ_kDownsample32kHzTbl, (WebRtc_Word16)7,
                (WebRtc_Word16)8, (WebRtc_Word16)0);
            if (w16_decodedLen<=320)
            {
                /* Not quite long enough, so we have to cheat a bit... */
                WebRtc_Word16 temp_len = w16_decodedLen - 6;
                w16_tmp = temp_len / 8;
                WebRtcSpl_DownsampleFast(
                      &pw16_decoded[6], temp_len,
                      pw16_decodedLB, w16_tmp,
                      (WebRtc_Word16*)WebRtcNetEQ_kDownsample32kHzTbl, (WebRtc_Word16)7,
                      (WebRtc_Word16)8, (WebRtc_Word16)0);
                WebRtcSpl_MemSetW16(&pw16_decodedLB[w16_tmp], 0, (40-w16_tmp));
            }
            else
            {
                WebRtcSpl_DownsampleFast(
                    &pw16_decoded[6], (WebRtc_Word16)(w16_decodedLen-6),
                    pw16_decodedLB, (WebRtc_Word16)(40),
                    (WebRtc_Word16*)WebRtcNetEQ_kDownsample32kHzTbl, (WebRtc_Word16)7,
                    (WebRtc_Word16)8, (WebRtc_Word16)0);
            }
#endif
#ifdef NETEQ_48KHZ_WIDEBAND
        }
        else /* if (inst->fs==48000) */
        {
            /*
             * TODO(hlundin) Why is the offset into pw16_expanded 6?
             */
            WebRtcSpl_DownsampleFast(
                &pw16_expanded[6], (WebRtc_Word16)(w16_expandedLen-6),
                pw16_expandedLB, (WebRtc_Word16)(100),
                (WebRtc_Word16*)WebRtcNetEQ_kDownsample48kHzTbl, (WebRtc_Word16)7,
                (WebRtc_Word16)12, (WebRtc_Word16)0);
            if (w16_decodedLen<=320)
            {
                /* Not quite long enough, so we have to cheat a bit... */
                /*
                 * TODO(hlundin): Is this correct? Downsampling is a factor 12
                 * but w16_tmp = temp_len / 8.
                 * (Was w16_tmp = ((w16_decodedLen-6)>>3) before re-write.)
                 */
                WebRtc_Word16 temp_len = w16_decodedLen - 6;
                w16_tmp = temp_len / 8;
                WebRtcSpl_DownsampleFast(
                    &pw16_decoded[6], temp_len,
                    pw16_decodedLB, w16_tmp,
                    (WebRtc_Word16*)WebRtcNetEQ_kDownsample48kHzTbl, (WebRtc_Word16)7,
                    (WebRtc_Word16)12, (WebRtc_Word16)0);
                WebRtcSpl_MemSetW16(&pw16_decodedLB[w16_tmp], 0, (40-w16_tmp));
            }
            else
            {
                WebRtcSpl_DownsampleFast(
                    &pw16_decoded[6], (WebRtc_Word16)(w16_decodedLen-6),
                    pw16_decodedLB, (WebRtc_Word16)(40),
                    (WebRtc_Word16*)WebRtcNetEQ_kDownsample48kHzTbl, (WebRtc_Word16)7,
                    (WebRtc_Word16)12, (WebRtc_Word16)0);
            }
#endif
        }

        /* Calculate correlation without any normalization (40 samples) */
        w16_tmp = WebRtcSpl_DivW32W16ResW16((WebRtc_Word32) inst->ExpandInst.w16_maxLag,
            (WebRtc_Word16) (fs_mult * 2)) + 1;
        w16_stopPos = WEBRTC_SPL_MIN(60, w16_tmp);
        w32_tmp = WEBRTC_SPL_MUL_16_16(w16_expmax, w16_newmax);
        if (w32_tmp > 26843546)
        {
            w16_tmp = 3;
        }
        else
        {
            w16_tmp = 0;
        }

        WebRtcNetEQ_CrossCorr(pw32_corr, pw16_decodedLB, pw16_expandedLB, 40,
            (WebRtc_Word16) w16_stopPos, w16_tmp, 1);

        /* Normalize correlation to 14 bits and put in a WebRtc_Word16 vector */
        WebRtcSpl_MemSetW16(pw16_corrVec, 0, (4 + 60 + 4));
        w32_tmp = WebRtcSpl_MaxAbsValueW32(pw32_corr, w16_stopPos);
        w16_tmp = 17 - WebRtcSpl_NormW32(w32_tmp);
        w16_tmp = WEBRTC_SPL_MAX(0, w16_tmp);

        WebRtcSpl_VectorBitShiftW32ToW16(pw16_corr, w16_stopPos, pw32_corr, w16_tmp);

        /* Calculate allowed starting point for peak finding.
         The peak location bestIndex must fulfill two criteria:
         (1) w16_bestIndex+w16_decodedLen < inst->timestampsPerCall+inst->ExpandInst.w16_overlap
         (2) w16_bestIndex+w16_decodedLen < w16_startPos */
        w16_tmp = WEBRTC_SPL_MAX(0, WEBRTC_SPL_MAX(w16_startPos,
                inst->timestampsPerCall+inst->ExpandInst.w16_overlap) - w16_decodedLen);
        /* Downscale starting index to 4kHz domain */
        w16_tmp2 = WebRtcSpl_DivW32W16ResW16((WebRtc_Word32) w16_tmp,
            (WebRtc_Word16) (fs_mult << 1));

#ifdef NETEQ_STEREO
    } /* end if (msInfo->msMode != NETEQ_SLAVE)  */

    if ((msInfo->msMode == NETEQ_MASTER) || (msInfo->msMode == NETEQ_MONO))
    {
        /* This is master or mono instance; find peak */
        WebRtcNetEQ_PeakDetection(&pw16_corr[w16_tmp2], w16_stopPos, 1, fs_mult, &w16_bestIndex,
            &w16_bestVal);
        w16_bestIndex += w16_tmp; /* compensate for modified starting index */
        msInfo->bestIndex = w16_bestIndex;
    }
    else if (msInfo->msMode == NETEQ_SLAVE)
    {
        /* Get peak location from master instance */
        w16_bestIndex = msInfo->bestIndex;
    }
    else
    {
        /* Invalid mode */
        return MASTER_SLAVE_ERROR;
    }

#else /* NETEQ_STEREO */

    /* Find peak */
    WebRtcNetEQ_PeakDetection(&pw16_corr[w16_tmp2], w16_stopPos, 1, fs_mult, &w16_bestIndex,
        &w16_bestVal);
    w16_bestIndex += w16_tmp; /* compensate for modified starting index */

#endif /* NETEQ_STEREO */

    /*
     * Ensure that underrun does not occur for 10ms case => we have to get at least
     * 10ms + overlap . (This should never happen thanks to the above modification of
     * peak-finding starting point.)
     * */
    while ((w16_bestIndex + w16_decodedLen) < (inst->timestampsPerCall
        + inst->ExpandInst.w16_overlap) || w16_bestIndex + w16_decodedLen < w16_startPos)
    {
        w16_bestIndex += w16_newLen; /* Jump one lag ahead */
    }
    pw16_decodedOut = pw16_outData + w16_bestIndex;

    /* Mute the new decoded data if needed (and unmute it linearly) */
    w16_interpLen = WEBRTC_SPL_MIN(60*fs_mult,
        w16_expandedLen-w16_bestIndex); /* this is the overlapping part of pw16_expanded */
    w16_interpLen = WEBRTC_SPL_MIN(w16_interpLen, w16_decodedLen);
    w16_inc = WebRtcSpl_DivW32W16ResW16(4194,
        fs_mult); /* in Q20, 0.004 for NB and 0.002 for WB */
    if (inst->w16_muteFactor < 16384)
    {
        WebRtcNetEQ_UnmuteSignal(pw16_decoded, &inst->w16_muteFactor, pw16_decoded, w16_inc,
            (WebRtc_Word16) w16_interpLen);
        WebRtcNetEQ_UnmuteSignal(&pw16_decoded[w16_interpLen], &inst->w16_muteFactor,
            &pw16_decodedOut[w16_interpLen], w16_inc,
            (WebRtc_Word16) (w16_decodedLen - w16_interpLen));
    }
    else
    {
        /* No muting needed */

        WEBRTC_SPL_MEMMOVE_W16(&pw16_decodedOut[w16_interpLen], &pw16_decoded[w16_interpLen],
            (w16_decodedLen-w16_interpLen));
    }

    /* Do overlap and interpolate linearly */
    w16_inc = WebRtcSpl_DivW32W16ResW16(16384, (WebRtc_Word16) (w16_interpLen + 1)); /* Q14 */
    w16_startfact = (16384 - w16_inc);
    WEBRTC_SPL_MEMMOVE_W16(pw16_outData, pw16_expanded, w16_bestIndex);
    WebRtcNetEQ_MixVoiceUnvoice(pw16_decodedOut, &pw16_expanded[w16_bestIndex], pw16_decoded,
        &w16_startfact, w16_inc, w16_interpLen);

    inst->w16_mode = MODE_MERGE;
    inst->ExpandInst.w16_consecExp = 0; /* Last was not expand any more */

    /* New added length (w16_startPos samples were borrowed) */
    *pw16_len = w16_bestIndex + w16_decodedLen - w16_startPos;

    /* Update VQmon parameter */
    inst->w16_concealedTS += (*pw16_len - w16_decodedLen);
    inst->w16_concealedTS = WEBRTC_SPL_MAX(0, inst->w16_concealedTS);

    /* Update in-call and post-call statistics */
    if (inst->ExpandInst.w16_expandMuteFactor == 0)
    {
        /* expansion generates noise only */
        inst->statInst.expandedNoiseSamples += (*pw16_len - w16_decodedLen);
    }
    else
    {
        /* expansion generates more than only noise */
        inst->statInst.expandedVoiceSamples += (*pw16_len - w16_decodedLen);
    }
    inst->statInst.expandLength += (*pw16_len - w16_decodedLen);


    /* Copy back the first part of the data to the speechHistory */

    WEBRTC_SPL_MEMCPY_W16(&inst->speechBuffer[inst->curPosition], pw16_outData, w16_startPos);


    /* Move data to within outData */

    WEBRTC_SPL_MEMMOVE_W16(pw16_outData, &pw16_outData[w16_startPos], (*pw16_len));

    return 0;
}

#undef     SCRATCH_pw16_expanded
#undef     SCRATCH_pw16_expandedLB
#undef     SCRATCH_pw16_decodedLB
#undef     SCRATCH_pw32_corr
#undef     SCRATCH_pw16_corrVec
#undef     SCRATCH_NETEQ_EXPAND