- Main Page
- Modules
- Data Structures
- Files
- Examples

- File List
- Globals

# arm_fir_decimate_f32.c

Go to the documentation of this file.

    00001 /* ----------------------------------------------------------------------
    00002 * Copyright (C) 2010 ARM Limited. All rights reserved.
    00003 *
    00004 * $Date:        29. November 2010
    00005 * $Revision:    V1.0.3
    00006 *
    00007 * Project:      CMSIS DSP Library
    00008 * Title:        arm_fir_decimate_f32.c
    00009 *
    00010 * Description:  FIR decimation for floating-point sequences.
    00011 *
    00012 * Target Processor: Cortex-M4/Cortex-M3
    00013 *
    00014 * Version 1.0.3 2010/11/29
    00015 *    Re-organized the CMSIS folders and updated documentation.
    00016 *
    00017 * Version 1.0.2 2010/11/11
    00018 *    Documentation updated.
    00019 *
    00020 * Version 1.0.1 2010/10/05
    00021 *    Production release and review comments incorporated.
    00022 *
    00023 * Version 1.0.0 2010/09/20
    00024 *    Production release and review comments incorporated
    00025 *
    00026 * Version 0.0.7  2010/06/10
    00027 *    Misra-C changes done
    00028 *
    00029 * -------------------------------------------------------------------- */
    00030
    00031 #include "arm_math.h"
    00032
    00129 void arm_fir_decimate_f32(
    00130   const arm_fir_decimate_instance_f32 * S,
    00131   float32_t * pSrc,
    00132   float32_t * pDst,
    00133   uint32_t blockSize)
    00134 {
    00135   float32_t *pState = S->pState;                 /* State pointer */
    00136   float32_t *pCoeffs = S->pCoeffs;               /* Coefficient pointer */
    00137   float32_t *pStateCurnt;                        /* Points to the current sample of the state */
    00138   float32_t *px, *pb;                            /* Temporary pointers for state and coefficient buffers */
    00139   float32_t sum0;                                /* Accumulator */
    00140   float32_t x0, c0;                              /* Temporary variables to hold state and coefficient values */
    00141   uint32_t numTaps = S->numTaps;                 /* Number of filter coefficients in the filter */
    00142   uint32_t i, tapCnt, blkCnt, outBlockSize = blockSize / S->M;  /* Loop counters */
    00143
    00144   /* S->pState buffer contains previous frame (numTaps - 1) samples */
    00145   /* pStateCurnt points to the location where the new input data should be written */
    00146   pStateCurnt = S->pState + (numTaps - 1u);
    00147
    00148   /* Total number of output samples to be computed */
    00149   blkCnt = outBlockSize;
    00150
    00151   while(blkCnt > 0u)
    00152   {
    00153     /* Copy decimation factor number of new input samples into the state buffer */
    00154     i = S->M;
    00155
    00156     do
    00157     {
    00158       *pStateCurnt++ = *pSrc++;
    00159
    00160     } while(--i);
    00161
    00162     /* Set accumulator to zero */
    00163     sum0 = 0.0f;
    00164
    00165     /* Initialize state pointer */
    00166     px = pState;
    00167
    00168     /* Initialize coeff pointer */
    00169     pb = pCoeffs;
    00170
    00171     /* Loop unrolling.  Process 4 taps at a time. */
    00172     tapCnt = numTaps >> 2;
    00173
    00174     /* Loop over the number of taps.  Unroll by a factor of 4.
    00175      ** Repeat until we've computed numTaps-4 coefficients. */
    00176     while(tapCnt > 0u)
    00177     {
    00178       /* Read the b[numTaps-1] coefficient */
    00179       c0 = *(pb++);
    00180
    00181       /* Read x[n-numTaps-1] sample */
    00182       x0 = *(px++);
    00183
    00184       /* Perform the multiply-accumulate */
    00185       sum0 += x0 * c0;
    00186
    00187       /* Read the b[numTaps-2] coefficient */
    00188       c0 = *(pb++);
    00189
    00190       /* Read x[n-numTaps-2] sample */
    00191       x0 = *(px++);
    00192
    00193       /* Perform the multiply-accumulate */
    00194       sum0 += x0 * c0;
    00195
    00196       /* Read the b[numTaps-3] coefficient */
    00197       c0 = *(pb++);
    00198
    00199       /* Read x[n-numTaps-3] sample */
    00200       x0 = *(px++);
    00201
    00202       /* Perform the multiply-accumulate */
    00203       sum0 += x0 * c0;
    00204
    00205       /* Read the b[numTaps-4] coefficient */
    00206       c0 = *(pb++);
    00207
    00208       /* Read x[n-numTaps-4] sample */
    00209       x0 = *(px++);
    00210
    00211       /* Perform the multiply-accumulate */
    00212       sum0 += x0 * c0;
    00213
    00214       /* Decrement the loop counter */
    00215       tapCnt--;
    00216     }
    00217
    00218     /* If the filter length is not a multiple of 4, compute the remaining filter taps */
    00219     tapCnt = numTaps % 0x4u;
    00220
    00221     while(tapCnt > 0u)
    00222     {
    00223       /* Read coefficients */
    00224       c0 = *(pb++);
    00225
    00226       /* Fetch 1 state variable */
    00227       x0 = *(px++);
    00228
    00229       /* Perform the multiply-accumulate */
    00230       sum0 += x0 * c0;
    00231
    00232       /* Decrement the loop counter */
    00233       tapCnt--;
    00234     }
    00235
    00236     /* Advance the state pointer by the decimation factor
    00237      * to process the next group of decimation factor number samples */
    00238     pState = pState + S->M;
    00239
    00240     /* The result is in the accumulator, store in the destination buffer. */
    00241     *pDst++ = sum0;
    00242
    00243     /* Decrement the loop counter */
    00244     blkCnt--;
    00245   }
    00246
    00247   /* Processing is complete.
    00248    ** Now copy the last numTaps - 1 samples to the satrt of the state buffer.
    00249    ** This prepares the state buffer for the next function call. */
    00250
    00251   /* Points to the start of the state buffer */
    00252   pStateCurnt = S->pState;
    00253
    00254   i = (numTaps - 1u) >> 2;
    00255
    00256   /* copy data */
    00257   while(i > 0u)
    00258   {
    00259     *pStateCurnt++ = *pState++;
    00260     *pStateCurnt++ = *pState++;
    00261     *pStateCurnt++ = *pState++;
    00262     *pStateCurnt++ = *pState++;
    00263
    00264     /* Decrement the loop counter */
    00265     i--;
    00266   }
    00267
    00268   i = (numTaps - 1u) % 0x04u;
    00269
    00270   /* copy data */
    00271   while(i > 0u)
    00272   {
    00273     *pStateCurnt++ = *pState++;
    00274
    00275     /* Decrement the loop counter */
    00276     i--;
    00277   }
    00278 }
    00279

All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines