Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2004-2010 NXP Software
      3  * Copyright (C) 2010 The Android Open Source Project
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 #include "BIQUAD.h"
     19 #include "BQ_2I_D32F32Cll_TRC_WRA_01_Private.h"
     20 #include "LVM_Macros.h"
     21 
     22 /**************************************************************************
     23  ASSUMPTIONS:
     24  COEFS-
     25  pBiquadState->coefs[0] is A2, pBiquadState->coefs[1] is A1
     26  pBiquadState->coefs[2] is A0, pBiquadState->coefs[3] is -B2
     27  pBiquadState->coefs[4] is -B1, these are in Q30 format
     28 
     29  DELAYS-
     30  pBiquadState->pDelays[0] is x(n-1)L in Q0 format
     31  pBiquadState->pDelays[1] is x(n-1)R in Q0 format
     32  pBiquadState->pDelays[2] is x(n-2)L in Q0 format
     33  pBiquadState->pDelays[3] is x(n-2)R in Q0 format
     34  pBiquadState->pDelays[4] is y(n-1)L in Q0 format
     35  pBiquadState->pDelays[5] is y(n-1)R in Q0 format
     36  pBiquadState->pDelays[6] is y(n-2)L in Q0 format
     37  pBiquadState->pDelays[7] is y(n-2)R in Q0 format
     38 ***************************************************************************/
     39 #ifdef BUILD_FLOAT
     40 void BQ_2I_D32F32C30_TRC_WRA_01 (           Biquad_FLOAT_Instance_t       *pInstance,
     41                                             LVM_FLOAT                    *pDataIn,
     42                                             LVM_FLOAT                    *pDataOut,
     43                                             LVM_INT16                    NrSamples)
     44 
     45 
     46     {
     47         LVM_FLOAT ynL,ynR,templ,tempd;
     48         LVM_INT16 ii;
     49         PFilter_State_FLOAT pBiquadState = (PFilter_State_FLOAT) pInstance;
     50 
     51          for (ii = NrSamples; ii != 0; ii--)
     52          {
     53 
     54 
     55             /**************************************************************************
     56                             PROCESSING OF THE LEFT CHANNEL
     57             ***************************************************************************/
     58             /* ynL= ( A2  * x(n-2)L  ) */
     59             ynL = pBiquadState->coefs[0] * pBiquadState->pDelays[2];
     60 
     61             /* ynL+= ( A1  * x(n-1)L  )*/
     62             templ = pBiquadState->coefs[1] * pBiquadState->pDelays[0];
     63             ynL += templ;
     64 
     65             /* ynL+= ( A0  * x(n)L  ) */
     66             templ = pBiquadState->coefs[2] * (*pDataIn);
     67             ynL += templ;
     68 
     69              /* ynL+= (-B2  * y(n-2)L  ) */
     70             templ = pBiquadState->coefs[3] * pBiquadState->pDelays[6];
     71             ynL += templ;
     72 
     73             /* ynL+= (-B1  * y(n-1)L  )*/
     74             templ = pBiquadState->coefs[4] * pBiquadState->pDelays[4];
     75             ynL += templ;
     76 
     77             /**************************************************************************
     78                             PROCESSING OF THE RIGHT CHANNEL
     79             ***************************************************************************/
     80             /* ynR= ( A2  * x(n-2)R  ) */
     81             ynR = pBiquadState->coefs[0] * pBiquadState->pDelays[3];
     82 
     83             /* ynR+= ( A1  * x(n-1)R  ) */
     84             templ = pBiquadState->coefs[1] * pBiquadState->pDelays[1];
     85             ynR += templ;
     86 
     87             /* ynR+= ( A0  * x(n)R  ) */
     88             tempd =* (pDataIn+1);
     89             templ = pBiquadState->coefs[2] * tempd;
     90             ynR += templ;
     91 
     92             /* ynR+= (-B2  * y(n-2)R  ) */
     93             templ = pBiquadState->coefs[3] * pBiquadState->pDelays[7];
     94             ynR += templ;
     95 
     96             /* ynR+= (-B1  * y(n-1)R  )  */
     97             templ = pBiquadState->coefs[4] * pBiquadState->pDelays[5];
     98             ynR += templ;
     99 
    100             /**************************************************************************
    101                             UPDATING THE DELAYS
    102             ***************************************************************************/
    103             pBiquadState->pDelays[7] = pBiquadState->pDelays[5]; /* y(n-2)R=y(n-1)R*/
    104             pBiquadState->pDelays[6] = pBiquadState->pDelays[4]; /* y(n-2)L=y(n-1)L*/
    105             pBiquadState->pDelays[3] = pBiquadState->pDelays[1]; /* x(n-2)R=x(n-1)R*/
    106             pBiquadState->pDelays[2] = pBiquadState->pDelays[0]; /* x(n-2)L=x(n-1)L*/
    107             pBiquadState->pDelays[5] = (LVM_FLOAT)ynR; /* Update y(n-1)R */
    108             pBiquadState->pDelays[4] = (LVM_FLOAT)ynL; /* Update y(n-1)L */
    109             pBiquadState->pDelays[0] = (*pDataIn); /* Update x(n-1)L */
    110             pDataIn++;
    111             pBiquadState->pDelays[1] = (*pDataIn); /* Update x(n-1)R */
    112             pDataIn++;
    113 
    114             /**************************************************************************
    115                             WRITING THE OUTPUT
    116             ***************************************************************************/
    117             *pDataOut = (LVM_FLOAT)ynL; /* Write Left output */
    118             pDataOut++;
    119             *pDataOut = (LVM_FLOAT)ynR; /* Write Right ouput */
    120             pDataOut++;
    121 
    122 
    123         }
    124 
    125     }
    126 #else
    127 void BQ_2I_D32F32C30_TRC_WRA_01 (           Biquad_Instance_t       *pInstance,
    128                                             LVM_INT32                    *pDataIn,
    129                                             LVM_INT32                    *pDataOut,
    130                                             LVM_INT16                    NrSamples)
    131 
    132 
    133     {
    134         LVM_INT32 ynL,ynR,templ,tempd;
    135         LVM_INT16 ii;
    136         PFilter_State pBiquadState = (PFilter_State) pInstance;
    137 
    138          for (ii = NrSamples; ii != 0; ii--)
    139          {
    140 
    141 
    142             /**************************************************************************
    143                             PROCESSING OF THE LEFT CHANNEL
    144             ***************************************************************************/
    145             /* ynL= ( A2 (Q30) * x(n-2)L (Q0) ) >>30 in Q0*/
    146             MUL32x32INTO32(pBiquadState->coefs[0],pBiquadState->pDelays[2],ynL,30)
    147 
    148             /* ynL+= ( A1 (Q30) * x(n-1)L (Q0) ) >> 30 in Q0*/
    149             MUL32x32INTO32(pBiquadState->coefs[1],pBiquadState->pDelays[0],templ,30)
    150             ynL+=templ;
    151 
    152             /* ynL+= ( A0 (Q30) * x(n)L (Q0) ) >> 30 in Q0*/
    153             MUL32x32INTO32(pBiquadState->coefs[2],*pDataIn,templ,30)
    154             ynL+=templ;
    155 
    156              /* ynL+= (-B2 (Q30) * y(n-2)L (Q0) ) >> 30 in Q0*/
    157             MUL32x32INTO32(pBiquadState->coefs[3],pBiquadState->pDelays[6],templ,30)
    158             ynL+=templ;
    159 
    160             /* ynL+= (-B1 (Q30) * y(n-1)L (Q0) ) >> 30 in Q0 */
    161             MUL32x32INTO32(pBiquadState->coefs[4],pBiquadState->pDelays[4],templ,30)
    162             ynL+=templ;
    163 
    164             /**************************************************************************
    165                             PROCESSING OF THE RIGHT CHANNEL
    166             ***************************************************************************/
    167             /* ynR= ( A2 (Q30) * x(n-2)R (Q0) ) >> 30 in Q0*/
    168             MUL32x32INTO32(pBiquadState->coefs[0],pBiquadState->pDelays[3],ynR,30)
    169 
    170             /* ynR+= ( A1 (Q30) * x(n-1)R (Q0) ) >> 30  in Q0*/
    171             MUL32x32INTO32(pBiquadState->coefs[1],pBiquadState->pDelays[1],templ,30)
    172             ynR+=templ;
    173 
    174             /* ynR+= ( A0 (Q30) * x(n)R (Q0) ) >> 30 in Q0*/
    175             tempd=*(pDataIn+1);
    176             MUL32x32INTO32(pBiquadState->coefs[2],tempd,templ,30)
    177             ynR+=templ;
    178 
    179             /* ynR+= (-B2 (Q30) * y(n-2)R (Q0) ) >> 30 in Q0*/
    180             MUL32x32INTO32(pBiquadState->coefs[3],pBiquadState->pDelays[7],templ,30)
    181             ynR+=templ;
    182 
    183             /* ynR+= (-B1 (Q30) * y(n-1)R (Q0) ) >> 30 in Q0 */
    184             MUL32x32INTO32(pBiquadState->coefs[4],pBiquadState->pDelays[5],templ,30)
    185             ynR+=templ;
    186 
    187             /**************************************************************************
    188                             UPDATING THE DELAYS
    189             ***************************************************************************/
    190             pBiquadState->pDelays[7]=pBiquadState->pDelays[5]; /* y(n-2)R=y(n-1)R*/
    191             pBiquadState->pDelays[6]=pBiquadState->pDelays[4]; /* y(n-2)L=y(n-1)L*/
    192             pBiquadState->pDelays[3]=pBiquadState->pDelays[1]; /* x(n-2)R=x(n-1)R*/
    193             pBiquadState->pDelays[2]=pBiquadState->pDelays[0]; /* x(n-2)L=x(n-1)L*/
    194             pBiquadState->pDelays[5]=(LVM_INT32)ynR; /* Update y(n-1)R in Q0*/
    195             pBiquadState->pDelays[4]=(LVM_INT32)ynL; /* Update y(n-1)L in Q0*/
    196             pBiquadState->pDelays[0]=(*pDataIn); /* Update x(n-1)L in Q0*/
    197             pDataIn++;
    198             pBiquadState->pDelays[1]=(*pDataIn); /* Update x(n-1)R in Q0*/
    199             pDataIn++;
    200 
    201             /**************************************************************************
    202                             WRITING THE OUTPUT
    203             ***************************************************************************/
    204             *pDataOut=(LVM_INT32)ynL; /* Write Left output in Q0*/
    205             pDataOut++;
    206             *pDataOut=(LVM_INT32)ynR; /* Write Right ouput in Q0*/
    207             pDataOut++;
    208 
    209 
    210         }
    211 
    212     }
    213 #endif /*BUILD_FLOAT*/
    214