/*
 * Copyright (C) 2004-2010 NXP Software
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/****************************************************************************************/
/*                                                                                      */
/* Includes                                                                             */
/*                                                                                      */
/****************************************************************************************/
#include "LVREV_Private.h"
#include "VectorArithmetic.h"


/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVREV_Process                                               */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Process function for the LVREV module.                                              */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance               Instance handle                                             */
/*  pInData                 Pointer to the input data                                   */
/*  pOutData                Pointer to the output data                                  */
/*  NumSamples              Number of samples in the input buffer                       */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVREV_Success           Succeeded                                                   */
/*  LVREV_INVALIDNUMSAMPLES NumSamples was larger than the maximum block size           */
/*  LVREV_NULLADDRESS       When one of hInstance, pInData or pOutData is NULL          */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1. The input and output buffers must be 32-bit aligned                              */
/*                                                                                      */
/****************************************************************************************/
LVREV_ReturnStatus_en LVREV_Process(LVREV_Handle_t      hInstance,
                                    const LVM_INT32     *pInData,
                                    LVM_INT32           *pOutData,
                                    const LVM_UINT16    NumSamples)
{
   LVREV_Instance_st     *pLVREV_Private = (LVREV_Instance_st *)hInstance;
   LVM_INT32             *pInput  = (LVM_INT32 *)pInData;
   LVM_INT32             *pOutput = pOutData;
   LVM_INT32             SamplesToProcess, RemainingSamples;
   LVM_INT32             format = 1;

    /*
     * Check for error conditions
     */

    /* Check for NULL pointers */
    if((hInstance == LVM_NULL) || (pInData == LVM_NULL) || (pOutData == LVM_NULL))
    {
        return LVREV_NULLADDRESS;
    }

    /*
     * Apply the new controls settings if required
     */
    if(pLVREV_Private->bControlPending == LVM_TRUE)
    {
        LVREV_ReturnStatus_en   errorCode;

        /*
         * Clear the pending flag and update the control settings
         */
        pLVREV_Private->bControlPending = LVM_FALSE;

        errorCode = LVREV_ApplyNewSettings (pLVREV_Private);

        if(errorCode != LVREV_SUCCESS)
        {
            return errorCode;
        }
    }

    /*
     * Trap the case where the number of samples is zero.
     */
    if (NumSamples == 0)
    {
        return LVREV_SUCCESS;
    }

    /*
     * If OFF copy and reformat the data as necessary
     */
    if (pLVREV_Private->CurrentParams.OperatingMode == LVM_MODE_OFF)
    {
        if(pInput != pOutput)
        {
            /*
             * Copy the data to the output buffer, convert to stereo is required
             */

            if(pLVREV_Private->CurrentParams.SourceFormat == LVM_MONO){
                MonoTo2I_32(pInput, pOutput, NumSamples);
            } else {
                Copy_16((LVM_INT16 *)pInput,
                        (LVM_INT16 *)pOutput,
                        (LVM_INT16)(NumSamples << 2)); // 32 bit data, stereo
            }
        }

        return LVREV_SUCCESS;
    }

    RemainingSamples = (LVM_INT32)NumSamples;

    if (pLVREV_Private->CurrentParams.SourceFormat != LVM_MONO)
    {
        format = 2;
    }

    while (RemainingSamples!=0)
    {
        /*
         * Process the data
         */

        if(RemainingSamples >  pLVREV_Private->MaxBlkLen)
        {
            SamplesToProcess =  pLVREV_Private->MaxBlkLen;
            RemainingSamples = (LVM_INT16)(RemainingSamples - SamplesToProcess);
        }
        else
        {
            SamplesToProcess = RemainingSamples;
            RemainingSamples = 0;
        }

        ReverbBlock(pInput, pOutput, pLVREV_Private, (LVM_UINT16)SamplesToProcess);

        pInput  = (LVM_INT32 *)(pInput +(SamplesToProcess*format));
        pOutput = (LVM_INT32 *)(pOutput+(SamplesToProcess*2));      // Always stereo output
    }

    return LVREV_SUCCESS;
}


/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                ReverbBlock                                                 */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Process function for the LVREV module.                                              */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance               Instance handle                                             */
/*  pInData                 Pointer to the input data                                   */
/*  pOutData                Pointer to the output data                                  */
/*  NumSamples              Number of samples in the input buffer                       */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVREV_Success           Succeeded                                                   */
/*  LVREV_INVALIDNUMSAMPLES NumSamples was larger than the maximum block size           */
/*  LVREV_NULLADDRESS       When one of hInstance, pInData or pOutData is NULL          */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1. The input and output buffers must be 32-bit aligned                              */
/*                                                                                      */
/****************************************************************************************/

void ReverbBlock(LVM_INT32 *pInput, LVM_INT32 *pOutput, LVREV_Instance_st *pPrivate, LVM_UINT16 NumSamples)
{
    LVM_INT16   j, size;
    LVM_INT32   *pDelayLine;
    LVM_INT32   *pDelayLineInput = pPrivate->pScratch;
    LVM_INT32   *pScratch = pPrivate->pScratch;
    LVM_INT32   *pIn;
    LVM_INT32   *pTemp = pPrivate->pInputSave;
    LVM_INT32   NumberOfDelayLines;

    /******************************************************************************
     * All calculations will go into the buffer pointed to by pTemp, this will    *
     * then be mixed with the original input to create the final output.          *
     *                                                                            *
     * When INPLACE processing is selected this must be a temporary buffer and    *
     * hence this is the worst case, so for simplicity this will ALWAYS be so     *
     *                                                                            *
     * The input buffer will remain untouched until the output of the mixer if    *
     * INPLACE processing is selected.                                            *
     *                                                                            *
     * The temp buffer will always be NumSamples in size regardless of MONO or    *
     * STEREO input. In the case of stereo input all processing is done in MONO   *
     * and the final output is converted to STEREO after the mixer                *
     ******************************************************************************/

    if(pPrivate->InstanceParams.NumDelays == LVREV_DELAYLINES_4 )
    {
        NumberOfDelayLines = 4;
    }
    else if(pPrivate->InstanceParams.NumDelays == LVREV_DELAYLINES_2 )
    {
        NumberOfDelayLines = 2;
    }
    else
    {
        NumberOfDelayLines = 1;
    }

    if(pPrivate->CurrentParams.SourceFormat == LVM_MONO)
    {
        pIn = pInput;
    }
    else
    {
        /*
         *  Stereo to mono conversion
         */

        From2iToMono_32( pInput,
                         pTemp,
                         (LVM_INT16)NumSamples);

        pIn = pTemp;
    }

    Mult3s_32x16(pIn,
                 (LVM_INT16)LVREV_HEADROOM,
                 pTemp,
                 (LVM_INT16)NumSamples);

    /*
     *  High pass filter
     */
    FO_1I_D32F32C31_TRC_WRA_01( &pPrivate->pFastCoef->HPCoefs,
                                pTemp,
                                pTemp,
                                (LVM_INT16)NumSamples);
    /*
     *  Low pass filter
     */
    FO_1I_D32F32C31_TRC_WRA_01( &pPrivate->pFastCoef->LPCoefs,
                                pTemp,
                                pTemp,
                                (LVM_INT16)NumSamples);

    /*
     *  Process all delay lines
     */

    for(j = 0; j < NumberOfDelayLines; j++)
    {
        pDelayLine = pPrivate->pScratchDelayLine[j];

        /*
         * All-pass filter with pop and click suppression
         */
        /* Get the smoothed, delayed output. Put it in the output buffer */
        MixSoft_2St_D32C31_SAT(&pPrivate->Mixer_APTaps[j],
                               pPrivate->pOffsetA[j],
                               pPrivate->pOffsetB[j],
                               pDelayLine,
                               (LVM_INT16)NumSamples);
        /* Re-align the all pass filter delay buffer and copying the fixed delay data to the AP delay in the process */
        Copy_16((LVM_INT16 *)&pPrivate->pDelay_T[j][NumSamples],
                (LVM_INT16 *)pPrivate->pDelay_T[j],
                (LVM_INT16)((pPrivate->T[j]-NumSamples) << 1));         /* 32-bit data */
        /* Apply the smoothed feedback and save to fixed delay input (currently empty) */
        MixSoft_1St_D32C31_WRA(&pPrivate->Mixer_SGFeedback[j],
                               pDelayLine,
                               &pPrivate->pDelay_T[j][pPrivate->T[j]-NumSamples],
                               (LVM_INT16)NumSamples);
        /* Sum into the AP delay line */
        Mac3s_Sat_32x16(&pPrivate->pDelay_T[j][pPrivate->T[j]-NumSamples],
                        -0x7fff,                                        /* Invert since the feedback coefficient is negative */
                        &pPrivate->pDelay_T[j][pPrivate->Delay_AP[j]-NumSamples],
                        (LVM_INT16)NumSamples);
        /* Apply smoothed feedforward sand save to fixed delay input (currently empty) */
        MixSoft_1St_D32C31_WRA(&pPrivate->Mixer_SGFeedforward[j],
                               &pPrivate->pDelay_T[j][pPrivate->Delay_AP[j]-NumSamples],
                               &pPrivate->pDelay_T[j][pPrivate->T[j]-NumSamples],
                               (LVM_INT16)NumSamples);
        /* Sum into the AP output */
        Mac3s_Sat_32x16(&pPrivate->pDelay_T[j][pPrivate->T[j]-NumSamples],
                        0x7fff,
                        pDelayLine,
                        (LVM_INT16)NumSamples);

        /*
         *  Feedback gain
         */
        MixSoft_1St_D32C31_WRA(&pPrivate->FeedbackMixer[j], pDelayLine, pDelayLine, NumSamples);

        /*
         *  Low pass filter
         */
        FO_1I_D32F32C31_TRC_WRA_01( &pPrivate->pFastCoef->RevLPCoefs[j],
                                    pDelayLine,
                                    pDelayLine,
                                    (LVM_INT16)NumSamples);
    }

    /*
     *  Apply rotation matrix and delay samples
     */
    for(j = 0; j < NumberOfDelayLines; j++)
    {

        Copy_16( (LVM_INT16*)(pTemp),
                 (LVM_INT16*)(pDelayLineInput),
                 (LVM_INT16)(NumSamples << 1));

        /*
         *  Rotation matrix mix
         */
        switch(j)
        {
            case 3:
                /*
                 *  Add delay line 1 and 2 contribution
                 */
                 Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[1], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);
                 Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[2], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);

                break;
            case 2:

                /*
                 *  Add delay line 0 and 3 contribution
                 */
                 Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[0], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);
                 Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[3], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);

                break;
            case 1:
                if(pPrivate->InstanceParams.NumDelays == LVREV_DELAYLINES_4)
                {
                    /*
                     *  Add delay line 0 and 3 contribution
                     */
                    Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[0], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);
                    Add2_Sat_32x32(pPrivate->pScratchDelayLine[3], pDelayLineInput, (LVM_INT16)NumSamples);

                }
                else
                {
                    /*
                     *  Add delay line 0 and 1 contribution
                     */
                     Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[0], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);
                     Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[1], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);

                }
                break;
            case 0:
                if(pPrivate->InstanceParams.NumDelays == LVREV_DELAYLINES_4)
                {
                    /*
                     *  Add delay line 1 and 2 contribution
                     */
                    Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[1], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);
                    Add2_Sat_32x32(pPrivate->pScratchDelayLine[2], pDelayLineInput, (LVM_INT16)NumSamples);

                }
                else if(pPrivate->InstanceParams.NumDelays == LVREV_DELAYLINES_2)
                {
                    /*
                     *  Add delay line 0 and 1 contribution
                     */
                    Add2_Sat_32x32(pPrivate->pScratchDelayLine[0], pDelayLineInput, (LVM_INT16)NumSamples);
                    Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[1], -0x8000, pDelayLineInput, (LVM_INT16)NumSamples);

                }
                else
                {
                    /*
                     *  Add delay line 0 contribution
                     */

                    /*             SOURCE                          DESTINATION*/
                    Add2_Sat_32x32(pPrivate->pScratchDelayLine[0], pDelayLineInput, (LVM_INT16)NumSamples);
                }
                break;
            default:
                break;
        }

        /*
         *  Delay samples
         */
        Copy_16((LVM_INT16 *)pDelayLineInput,
                (LVM_INT16 *)&pPrivate->pDelay_T[j][pPrivate->T[j]-NumSamples],
                (LVM_INT16)(NumSamples << 1));              /* 32-bit data */

    }


    /*
     *  Create stereo output
     */
    switch(pPrivate->InstanceParams.NumDelays)
    {
        case LVREV_DELAYLINES_4:
             Add2_Sat_32x32(pPrivate->pScratchDelayLine[3],
                            pPrivate->pScratchDelayLine[0],
                            (LVM_INT16)NumSamples);
             Add2_Sat_32x32(pPrivate->pScratchDelayLine[2],
                            pPrivate->pScratchDelayLine[1],
                            (LVM_INT16)NumSamples);


            JoinTo2i_32x32(pPrivate->pScratchDelayLine[0],
                           pPrivate->pScratchDelayLine[1],
                           pTemp,
                           (LVM_INT16)NumSamples);


            break;
        case LVREV_DELAYLINES_2:

             Copy_16( (LVM_INT16*)pPrivate->pScratchDelayLine[1],
                      (LVM_INT16*)pScratch,
                      (LVM_INT16)(NumSamples << 1));

            Mac3s_Sat_32x16(pPrivate->pScratchDelayLine[0],
                            -0x8000,
                            pScratch,
                            (LVM_INT16)NumSamples);

             Add2_Sat_32x32(pPrivate->pScratchDelayLine[1],
                            pPrivate->pScratchDelayLine[0],
                            (LVM_INT16)NumSamples);


             JoinTo2i_32x32(pPrivate->pScratchDelayLine[0],
                            pScratch,
                            pTemp,
                            (LVM_INT16)NumSamples);
            break;
        case LVREV_DELAYLINES_1:
            MonoTo2I_32(pPrivate->pScratchDelayLine[0],
                        pTemp,
                        (LVM_INT16)NumSamples);
            break;
        default:
            break;
    }


    /*
     *  Dry/wet mixer
     */

    size = (LVM_INT16)(NumSamples << 1);
    MixSoft_2St_D32C31_SAT(&pPrivate->BypassMixer,
                           pTemp,
                           pTemp,
                           pOutput,
                           size);

    /* Apply Gain*/

    Shift_Sat_v32xv32 (LVREV_OUTPUTGAIN_SHIFT,
                       pOutput,
                       pOutput,
                       size);

    MixSoft_1St_D32C31_WRA(&pPrivate->GainMixer,
                           pOutput,
                           pOutput,
                           size);

    return;
}


/* End of file */