| /* |
| * 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 */ |
| |
