arm_fir_decimate_f32.c
Go to the documentation of this file.
00001 /* ---------------------------------------------------------------------- 00002 * Copyright (C) 2011 ARM Limited. All rights reserved. 00003 * 00004 * $Date: 15. December 2011 00005 * $Revision: V2.0.0 00006 * 00007 * Project: Cortex-R DSP Library 00008 * Title: arm_fir_decimate_f32.c 00009 * 00010 * Description: FIR decimation for floating-point sequences. 00011 * 00012 * Target Processor: Cortex-R4/R5 00013 * 00014 * Version 1.0.0 2011/03/08 00015 * Alpha release. 00016 * 00017 * Version 1.0.1 2011/09/30 00018 * Beta release. 00019 * 00020 * Version 2.0.0 2011/12/15 00021 * Final release. 00022 * 00023 * -------------------------------------------------------------------- */ 00024 00025 #include "arm_math.h" 00026 00123 void arm_fir_decimate_f32( 00124 const arm_fir_decimate_instance_f32 * S, 00125 float32_t * pSrc, 00126 float32_t * pDst, 00127 uint32_t blockSize) 00128 { 00129 float32_t *pState = S->pState; /* State pointer */ 00130 float32_t *pCoeffs = S->pCoeffs; /* Coefficient pointer */ 00131 float32_t *pStateCurnt; /* Points to the current sample of the state */ 00132 float32_t *px, *pb; /* Temporary pointers for state and coefficient buffers */ 00133 float32_t sum0; /* Accumulator */ 00134 float32_t x0, c0; /* Temporary variables to hold state and coefficient values */ 00135 uint32_t numTaps = S->numTaps; /* Number of filter coefficients in the filter */ 00136 uint32_t i, tapCnt, blkCnt, outBlockSize = blockSize / S->M; /* Loop counters */ 00137 uint32_t blkCntN4; 00138 float32_t *px0, *px1, *px2, *px3; 00139 float32_t acc0, acc1, acc2, acc3; 00140 float32_t x1, x2, x3; 00141 00142 00143 /* S->pState buffer contains previous frame (numTaps - 1) samples */ 00144 /* pStateCurnt points to the location where the new input data should be written */ 00145 pStateCurnt = S->pState + (numTaps - 1u); 00146 00147 /* Total number of output samples to be computed */ 00148 blkCnt = outBlockSize / 4; 00149 blkCntN4 = outBlockSize - (4*blkCnt); 00150 00151 while(blkCnt > 0u) 00152 { 00153 /* Copy 4 * decimation factor number of new input samples into the state buffer */ 00154 i = 4 * S->M; 00155 00156 do 00157 { 00158 *pStateCurnt++ = *pSrc++; 00159 00160 } while(--i); 00161 00162 /* Set accumulators to zero */ 00163 acc0 = 0.0f; 00164 acc1 = 0.0f; 00165 acc2 = 0.0f; 00166 acc3 = 0.0f; 00167 00168 /* Initialize state pointer for all the samples */ 00169 px0 = pState; 00170 px1 = pState + S->M; 00171 px2 = pState + 2 * S->M; 00172 px3 = pState + 3 * S->M; 00173 00174 /* Initialize coeff pointer */ 00175 pb = pCoeffs; 00176 00177 /* Loop unrolling. Process 4 taps at a time. */ 00178 tapCnt = numTaps >> 2; 00179 00180 /* Loop over the number of taps. Unroll by a factor of 4. 00181 ** Repeat until we've computed numTaps-4 coefficients. */ 00182 00183 while(tapCnt > 0u) 00184 { 00185 /* Read the b[numTaps-1] coefficient */ 00186 c0 = *(pb++); 00187 00188 /* Read x[n-numTaps-1] sample for acc0 */ 00189 x0 = *(px0++); 00190 /* Read x[n-numTaps-1] sample for acc1 */ 00191 x1 = *(px1++); 00192 /* Read x[n-numTaps-1] sample for acc2 */ 00193 x2 = *(px2++); 00194 /* Read x[n-numTaps-1] sample for acc3 */ 00195 x3 = *(px3++); 00196 00197 /* Perform the multiply-accumulate */ 00198 acc0 += x0 * c0; 00199 acc1 += x1 * c0; 00200 acc2 += x2 * c0; 00201 acc3 += x3 * c0; 00202 00203 /* Read the b[numTaps-2] coefficient */ 00204 c0 = *(pb++); 00205 00206 /* Read x[n-numTaps-2] sample for acc0, acc1, acc2, acc3 */ 00207 x0 = *(px0++); 00208 x1 = *(px1++); 00209 x2 = *(px2++); 00210 x3 = *(px3++); 00211 00212 /* Perform the multiply-accumulate */ 00213 acc0 += x0 * c0; 00214 acc1 += x1 * c0; 00215 acc2 += x2 * c0; 00216 acc3 += x3 * c0; 00217 00218 /* Read the b[numTaps-3] coefficient */ 00219 c0 = *(pb++); 00220 00221 /* Read x[n-numTaps-3] sample acc0, acc1, acc2, acc3 */ 00222 x0 = *(px0++); 00223 x1 = *(px1++); 00224 x2 = *(px2++); 00225 x3 = *(px3++); 00226 00227 /* Perform the multiply-accumulate */ 00228 acc0 += x0 * c0; 00229 acc1 += x1 * c0; 00230 acc2 += x2 * c0; 00231 acc3 += x3 * c0; 00232 00233 /* Read the b[numTaps-4] coefficient */ 00234 c0 = *(pb++); 00235 00236 /* Read x[n-numTaps-4] sample acc0, acc1, acc2, acc3 */ 00237 x0 = *(px0++); 00238 x1 = *(px1++); 00239 x2 = *(px2++); 00240 x3 = *(px3++); 00241 00242 /* Perform the multiply-accumulate */ 00243 acc0 += x0 * c0; 00244 acc1 += x1 * c0; 00245 acc2 += x2 * c0; 00246 acc3 += x3 * c0; 00247 00248 /* Decrement the loop counter */ 00249 tapCnt--; 00250 } 00251 00252 /* If the filter length is not a multiple of 4, compute the remaining filter taps */ 00253 tapCnt = numTaps % 0x4u; 00254 00255 while(tapCnt > 0u) 00256 { 00257 /* Read coefficients */ 00258 c0 = *(pb++); 00259 00260 /* Fetch state variables for acc0, acc1, acc2, acc3 */ 00261 x0 = *(px0++); 00262 x1 = *(px1++); 00263 x2 = *(px2++); 00264 x3 = *(px3++); 00265 00266 /* Perform the multiply-accumulate */ 00267 acc0 += x0 * c0; 00268 acc1 += x1 * c0; 00269 acc2 += x2 * c0; 00270 acc3 += x3 * c0; 00271 00272 /* Decrement the loop counter */ 00273 tapCnt--; 00274 } 00275 00276 /* Advance the state pointer by the decimation factor 00277 * to process the next group of decimation factor number samples */ 00278 pState = pState + 4 * S->M; 00279 00280 /* The result is in the accumulator, store in the destination buffer. */ 00281 *pDst++ = acc0; 00282 *pDst++ = acc1; 00283 *pDst++ = acc2; 00284 *pDst++ = acc3; 00285 00286 /* Decrement the loop counter */ 00287 blkCnt--; 00288 } 00289 00290 while(blkCntN4 > 0u) 00291 { 00292 /* Copy decimation factor number of new input samples into the state buffer */ 00293 i = S->M; 00294 00295 do 00296 { 00297 *pStateCurnt++ = *pSrc++; 00298 00299 } while(--i); 00300 00301 /* Set accumulator to zero */ 00302 sum0 = 0.0f; 00303 00304 /* Initialize state pointer */ 00305 px = pState; 00306 00307 /* Initialize coeff pointer */ 00308 pb = pCoeffs; 00309 00310 /* Loop unrolling. Process 4 taps at a time. */ 00311 tapCnt = numTaps >> 2; 00312 00313 /* Loop over the number of taps. Unroll by a factor of 4. 00314 ** Repeat until we've computed numTaps-4 coefficients. */ 00315 while(tapCnt > 0u) 00316 { 00317 /* Read the b[numTaps-1] coefficient */ 00318 c0 = *(pb++); 00319 00320 /* Read x[n-numTaps-1] sample */ 00321 x0 = *(px++); 00322 00323 /* Perform the multiply-accumulate */ 00324 sum0 += x0 * c0; 00325 00326 /* Read the b[numTaps-2] coefficient */ 00327 c0 = *(pb++); 00328 00329 /* Read x[n-numTaps-2] sample */ 00330 x0 = *(px++); 00331 00332 /* Perform the multiply-accumulate */ 00333 sum0 += x0 * c0; 00334 00335 /* Read the b[numTaps-3] coefficient */ 00336 c0 = *(pb++); 00337 00338 /* Read x[n-numTaps-3] sample */ 00339 x0 = *(px++); 00340 00341 /* Perform the multiply-accumulate */ 00342 sum0 += x0 * c0; 00343 00344 /* Read the b[numTaps-4] coefficient */ 00345 c0 = *(pb++); 00346 00347 /* Read x[n-numTaps-4] sample */ 00348 x0 = *(px++); 00349 00350 /* Perform the multiply-accumulate */ 00351 sum0 += x0 * c0; 00352 00353 /* Decrement the loop counter */ 00354 tapCnt--; 00355 } 00356 00357 /* If the filter length is not a multiple of 4, compute the remaining filter taps */ 00358 tapCnt = numTaps % 0x4u; 00359 00360 while(tapCnt > 0u) 00361 { 00362 /* Read coefficients */ 00363 c0 = *(pb++); 00364 00365 /* Fetch 1 state variable */ 00366 x0 = *(px++); 00367 00368 /* Perform the multiply-accumulate */ 00369 sum0 += x0 * c0; 00370 00371 /* Decrement the loop counter */ 00372 tapCnt--; 00373 } 00374 00375 /* Advance the state pointer by the decimation factor 00376 * to process the next group of decimation factor number samples */ 00377 pState = pState + S->M; 00378 00379 /* The result is in the accumulator, store in the destination buffer. */ 00380 *pDst++ = sum0; 00381 00382 /* Decrement the loop counter */ 00383 blkCntN4--; 00384 } 00385 00386 /* Processing is complete. 00387 ** Now copy the last numTaps - 1 samples to the satrt of the state buffer. 00388 ** This prepares the state buffer for the next function call. */ 00389 00390 /* Points to the start of the state buffer */ 00391 pStateCurnt = S->pState; 00392 00393 i = (numTaps - 1u) >> 2; 00394 00395 /* copy data */ 00396 while(i > 0u) 00397 { 00398 *pStateCurnt++ = *pState++; 00399 *pStateCurnt++ = *pState++; 00400 *pStateCurnt++ = *pState++; 00401 *pStateCurnt++ = *pState++; 00402 00403 /* Decrement the loop counter */ 00404 i--; 00405 } 00406 00407 i = (numTaps - 1u) % 0x04u; 00408 00409 /* copy data */ 00410 while(i > 0u) 00411 { 00412 *pStateCurnt++ = *pState++; 00413 00414 /* Decrement the loop counter */ 00415 i--; 00416 } 00417 } 00418
