CMSIS DSP Software Library: arm_conv_q15.c Source File
Main Page
Modules
Data Structures
Files
Examples
File List
Globals
arm_conv_q15.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_conv_q15.c
00009 *
00010 * Description: Q15 Convolution.
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
00065 void arm_conv_q15(
00066 q15_t * pSrcA,
00067 uint32_t srcALen,
00068 q15_t * pSrcB,
00069 uint32_t srcBLen,
00070 q15_t * pDst)
00071 {
00072 q15_t *pIn1; /* inputA pointer */
00073 q15_t *pIn2; /* inputB pointer */
00074 q15_t *pOut = pDst; /* output pointer */
00075 q63_t sum, acc0, acc1, acc2, acc3; /* Accumulator */
00076 q15_t *px; /* Intermediate inputA pointer */
00077 q15_t *py; /* Intermediate inputB pointer */
00078 q15_t *pSrc1, *pSrc2; /* Intermediate pointers */
00079 q31_t x0, x1, x2, x3, c0; /* Temporary variables to hold state and coefficient values */
00080 uint32_t blockSize1, blockSize2, blockSize3, j, k, count, blkCnt; /* loop counter */
00081 q31_t *pb; /* 32 bit pointer for inputB buffer */
00082
00083
00084 /* The algorithm implementation is based on the lengths of the inputs. */
00085 /* srcB is always made to slide across srcA. */
00086 /* So srcBLen is always considered as shorter or equal to srcALen */
00087 if(srcALen >= srcBLen)
00088 {
00089 /* Initialization of inputA pointer */
00090 pIn1 = pSrcA;
00091
00092 /* Initialization of inputB pointer */
00093 pIn2 = pSrcB;
00094 }
00095 else
00096 {
00097 /* Initialization of inputA pointer */
00098 pIn1 = pSrcB;
00099
00100 /* Initialization of inputB pointer */
00101 pIn2 = pSrcA;
00102
00103 /* srcBLen is always considered as shorter or equal to srcALen */
00104 j = srcBLen;
00105 srcBLen = srcALen;
00106 srcALen = j;
00107 }
00108
00109 /* conv(x,y) at n = x[n] * y[0] + x[n-1] * y[1] + x[n-2] * y[2] + ...+ x[n-N+1] * y[N -1] */
00110 /* The function is internally
00111 * divided into three stages according to the number of multiplications that has to be
00112 * taken place between inputA samples and inputB samples. In the first stage of the
00113 * algorithm, the multiplications increase by one for every iteration.
00114 * In the second stage of the algorithm, srcBLen number of multiplications are done.
00115 * In the third stage of the algorithm, the multiplications decrease by one
00116 * for every iteration. */
00117
00118 /* The algorithm is implemented in three stages.
00119 The loop counters of each stage is initiated here. */
00120 blockSize1 = srcBLen - 1u;
00121 blockSize2 = srcALen - (srcBLen - 1u);
00122
00123 /* --------------------------
00124 * Initializations of stage1
00125 * -------------------------*/
00126
00127 /* sum = x[0] * y[0]
00128 * sum = x[0] * y[1] + x[1] * y[0]
00129 * ....
00130 * sum = x[0] * y[srcBlen - 1] + x[1] * y[srcBlen - 2] +...+ x[srcBLen - 1] * y[0]
00131 */
00132
00133 /* In this stage the MAC operations are increased by 1 for every iteration.
00134 The count variable holds the number of MAC operations performed */
00135 count = 1u;
00136
00137 /* Working pointer of inputA */
00138 px = pIn1;
00139
00140 /* Working pointer of inputB */
00141 py = pIn2;
00142
00143
00144 /* ------------------------
00145 * Stage1 process
00146 * ----------------------*/
00147
00148 /* For loop unrolling by 4, this stage is divided into two. */
00149 /* First part of this stage computes the MAC operations less than 4 */
00150 /* Second part of this stage computes the MAC operations greater than or equal to 4 */
00151
00152 /* The first part of the stage starts here */
00153 while((count < 4u) && (blockSize1 > 0u))
00154 {
00155 /* Accumulator is made zero for every iteration */
00156 sum = 0;
00157
00158 /* Loop over number of MAC operations between
00159 * inputA samples and inputB samples */
00160 k = count;
00161
00162 while(k > 0u)
00163 {
00164 /* Perform the multiply-accumulates */
00165 sum = __SMLALD(*px++, *py--, sum);
00166
00167 /* Decrement the loop counter */
00168 k--;
00169 }
00170
00171 /* Store the result in the accumulator in the destination buffer. */
00172 *pOut++ = (q15_t) (__SSAT((sum >> 15), 16));
00173
00174 /* Update the inputA and inputB pointers for next MAC calculation */
00175 py = pIn2 + count;
00176 px = pIn1;
00177
00178 /* Increment the MAC count */
00179 count++;
00180
00181 /* Decrement the loop counter */
00182 blockSize1--;
00183 }
00184
00185 /* The second part of the stage starts here */
00186 /* The internal loop, over count, is unrolled by 4 */
00187 /* To, read the last two inputB samples using SIMD:
00188 * y[srcBLen] and y[srcBLen-1] coefficients, py is decremented by 1 */
00189 py = py - 1;
00190
00191 while(blockSize1 > 0u)
00192 {
00193 /* Accumulator is made zero for every iteration */
00194 sum = 0;
00195
00196 /* Apply loop unrolling and compute 4 MACs simultaneously. */
00197 k = count >> 2u;
00198
00199 /* First part of the processing with loop unrolling. Compute 4 MACs at a time.
00200 ** a second loop below computes MACs for the remaining 1 to 3 samples. */
00201 while(k > 0u)
00202 {
00203 /* Perform the multiply-accumulates */
00204 /* x[0], x[1] are multiplied with y[srcBLen - 1], y[srcBLen - 2] respectively */
00205 sum = __SMLALDX(*__SIMD32(px)++, *__SIMD32(py)--, sum);
00206 /* x[2], x[3] are multiplied with y[srcBLen - 3], y[srcBLen - 4] respectively */
00207 sum = __SMLALDX(*__SIMD32(px)++, *__SIMD32(py)--, sum);
00208
00209 /* Decrement the loop counter */
00210 k--;
00211 }
00212
00213 /* For the next MAC operations, the pointer py is used without SIMD
00214 * So, py is incremented by 1 */
00215 py = py + 1u;
00216
00217 /* If the count is not a multiple of 4, compute any remaining MACs here.
00218 ** No loop unrolling is used. */
00219 k = count % 0x4u;
00220
00221 while(k > 0u)
00222 {
00223 /* Perform the multiply-accumulates */
00224 sum = __SMLALD(*px++, *py--, sum);
00225
00226 /* Decrement the loop counter */
00227 k--;
00228 }
00229
00230 /* Store the result in the accumulator in the destination buffer. */
00231 *pOut++ = (q15_t) (__SSAT((sum >> 15), 16));
00232
00233 /* Update the inputA and inputB pointers for next MAC calculation */
00234 py = pIn2 + (count - 1u);
00235 px = pIn1;
00236
00237 /* Increment the MAC count */
00238 count++;
00239
00240 /* Decrement the loop counter */
00241 blockSize1--;
00242 }
00243
00244 /* --------------------------
00245 * Initializations of stage2
00246 * ------------------------*/
00247
00248 /* sum = x[0] * y[srcBLen-1] + x[1] * y[srcBLen-2] +...+ x[srcBLen-1] * y[0]
00249 * sum = x[1] * y[srcBLen-1] + x[2] * y[srcBLen-2] +...+ x[srcBLen] * y[0]
00250 * ....
00251 * sum = x[srcALen-srcBLen-2] * y[srcBLen-1] + x[srcALen] * y[srcBLen-2] +...+ x[srcALen-1] * y[0]
00252 */
00253
00254 /* Working pointer of inputA */
00255 px = pIn1;
00256
00257 /* Working pointer of inputB */
00258 pSrc2 = pIn2 + (srcBLen - 1u);
00259 py = pSrc2;
00260
00261 /* Initialize inputB pointer of type q31 */
00262 pb = (q31_t *) (py - 1u);
00263
00264 /* count is the index by which the pointer pIn1 to be incremented */
00265 count = 1u;
00266
00267
00268 /* --------------------
00269 * Stage2 process
00270 * -------------------*/
00271
00272 /* Stage2 depends on srcBLen as in this stage srcBLen number of MACS are performed.
00273 * So, to loop unroll over blockSize2,
00274 * srcBLen should be greater than or equal to 4 */
00275 if(srcBLen >= 4u)
00276 {
00277 /* Loop unroll over blockSize2, by 4 */
00278 blkCnt = blockSize2 >> 2u;
00279
00280 while(blkCnt > 0u)
00281 {
00282 /* Set all accumulators to zero */
00283 acc0 = 0;
00284 acc1 = 0;
00285 acc2 = 0;
00286 acc3 = 0;
00287
00288
00289 /* read x[0], x[1] samples */
00290 x0 = *(q31_t *) (px++);
00291 /* read x[1], x[2] samples */
00292 x1 = *(q31_t *) (px++);
00293
00294
00295 /* Apply loop unrolling and compute 4 MACs simultaneously. */
00296 k = srcBLen >> 2u;
00297
00298 /* First part of the processing with loop unrolling. Compute 4 MACs at a time.
00299 ** a second loop below computes MACs for the remaining 1 to 3 samples. */
00300 do
00301 {
00302 /* Read the last two inputB samples using SIMD:
00303 * y[srcBLen - 1] and y[srcBLen - 2] */
00304 c0 = *(pb--);
00305
00306 /* acc0 += x[0] * y[srcBLen - 1] + x[1] * y[srcBLen - 2] */
00307 acc0 = __SMLALDX(x0, c0, acc0);
00308
00309 /* acc1 += x[1] * y[srcBLen - 1] + x[2] * y[srcBLen - 2] */
00310 acc1 = __SMLALDX(x1, c0, acc1);
00311
00312 /* Read x[2], x[3] */
00313 x2 = *(q31_t *) (px++);
00314
00315 /* Read x[3], x[4] */
00316 x3 = *(q31_t *) (px++);
00317
00318 /* acc2 += x[2] * y[srcBLen - 1] + x[3] * y[srcBLen - 2] */
00319 acc2 = __SMLALDX(x2, c0, acc2);
00320
00321 /* acc3 += x[3] * y[srcBLen - 1] + x[4] * y[srcBLen - 2] */
00322 acc3 = __SMLALDX(x3, c0, acc3);
00323
00324 /* Read y[srcBLen - 3] and y[srcBLen - 4] */
00325 c0 = *(pb--);
00326
00327 /* acc0 += x[2] * y[srcBLen - 3] + x[3] * y[srcBLen - 4] */
00328 acc0 = __SMLALDX(x2, c0, acc0);
00329
00330 /* acc1 += x[3] * y[srcBLen - 3] + x[4] * y[srcBLen - 4] */
00331 acc1 = __SMLALDX(x3, c0, acc1);
00332
00333 /* Read x[4], x[5] */
00334 x0 = *(q31_t *) (px++);
00335
00336 /* Read x[5], x[6] */
00337 x1 = *(q31_t *) (px++);
00338
00339 /* acc2 += x[4] * y[srcBLen - 3] + x[5] * y[srcBLen - 4] */
00340 acc2 = __SMLALDX(x0, c0, acc2);
00341
00342 /* acc3 += x[5] * y[srcBLen - 3] + x[6] * y[srcBLen - 4] */
00343 acc3 = __SMLALDX(x1, c0, acc3);
00344
00345 } while(--k);
00346
00347 /* For the next MAC operations, SIMD is not used
00348 * So, the 16 bit pointer if inputB, py is updated */
00349 py = (q15_t *) pb;
00350 py = py + 1;
00351
00352 /* If the srcBLen is not a multiple of 4, compute any remaining MACs here.
00353 ** No loop unrolling is used. */
00354 k = srcBLen % 0x4u;
00355
00356 if(k == 1u)
00357 {
00358 /* Read y[srcBLen - 5] */
00359 c0 = *(py);
00360
00361 /* Read x[7] */
00362 x3 = *(q31_t *) px++;
00363
00364 /* Perform the multiply-accumulates */
00365 acc0 = __SMLALD(x0, c0, acc0);
00366 acc1 = __SMLALD(x1, c0, acc1);
00367 acc2 = __SMLALDX(x1, c0, acc2);
00368 acc3 = __SMLALDX(x3, c0, acc3);
00369 }
00370
00371 if(k == 2u)
00372 {
00373 /* Read y[srcBLen - 5], y[srcBLen - 6] */
00374 c0 = *(pb);
00375
00376 /* Read x[7], x[8] */
00377 x3 = *(q31_t *) px++;
00378
00379 /* Read x[9] */
00380 x2 = *(q31_t *) px++;
00381
00382 /* Perform the multiply-accumulates */
00383 acc0 = __SMLALDX(x0, c0, acc0);
00384 acc1 = __SMLALDX(x1, c0, acc1);
00385 acc2 = __SMLALDX(x3, c0, acc2);
00386 acc3 = __SMLALDX(x2, c0, acc3);
00387 }
00388
00389 if(k == 3u)
00390 {
00391 /* Read y[srcBLen - 5], y[srcBLen - 6] */
00392 c0 = *pb--;
00393
00394 /* Read x[7], x[8] */
00395 x3 = *(q31_t *) px++;
00396
00397 /* Read x[9] */
00398 x2 = *(q31_t *) px++;
00399
00400 /* Perform the multiply-accumulates */
00401 acc0 = __SMLALDX(x0, c0, acc0);
00402 acc1 = __SMLALDX(x1, c0, acc1);
00403 acc2 = __SMLALDX(x3, c0, acc2);
00404 acc3 = __SMLALDX(x2, c0, acc3);
00405
00406 /* Read y[srcBLen - 7] */
00407 c0 = (q15_t) (*pb >> 16);
00408
00409 /* Read x[10] */
00410 x3 = *(q31_t *) px++;
00411
00412 /* Perform the multiply-accumulates */
00413 acc0 = __SMLALDX(x1, c0, acc0);
00414 acc1 = __SMLALD(x2, c0, acc1);
00415 acc2 = __SMLALDX(x2, c0, acc2);
00416 acc3 = __SMLALDX(x3, c0, acc3);
00417 }
00418
00419 /* Store the results in the accumulators in the destination buffer. */
00420 *__SIMD32(pOut)++ =
00421 __PKHBT(__SSAT((acc0 >> 15), 16), __SSAT((acc1 >> 15), 16), 16);
00422 *__SIMD32(pOut)++ =
00423 __PKHBT(__SSAT((acc2 >> 15), 16), __SSAT((acc3 >> 15), 16), 16);
00424
00425 /* Update the inputA and inputB pointers for next MAC calculation */
00426 px = pIn1 + (count * 4u);
00427 py = pSrc2;
00428 pb = (q31_t *) (py - 1);
00429
00430 /* Increment the pointer pIn1 index, count by 1 */
00431 count++;
00432
00433 /* Decrement the loop counter */
00434 blkCnt--;
00435 }
00436
00437 /* If the blockSize2 is not a multiple of 4, compute any remaining output samples here.
00438 ** No loop unrolling is used. */
00439 blkCnt = blockSize2 % 0x4u;
00440
00441 while(blkCnt > 0u)
00442 {
00443 /* Accumulator is made zero for every iteration */
00444 sum = 0;
00445
00446 /* Apply loop unrolling and compute 4 MACs simultaneously. */
00447 k = srcBLen >> 2u;
00448
00449 /* First part of the processing with loop unrolling. Compute 4 MACs at a time.
00450 ** a second loop below computes MACs for the remaining 1 to 3 samples. */
00451 while(k > 0u)
00452 {
00453 /* Perform the multiply-accumulates */
00454 sum += (q63_t) ((q31_t) * px++ * *py--);
00455 sum += (q63_t) ((q31_t) * px++ * *py--);
00456 sum += (q63_t) ((q31_t) * px++ * *py--);
00457 sum += (q63_t) ((q31_t) * px++ * *py--);
00458
00459 /* Decrement the loop counter */
00460 k--;
00461 }
00462
00463 /* If the srcBLen is not a multiple of 4, compute any remaining MACs here.
00464 ** No loop unrolling is used. */
00465 k = srcBLen % 0x4u;
00466
00467 while(k > 0u)
00468 {
00469 /* Perform the multiply-accumulates */
00470 sum += (q63_t) ((q31_t) * px++ * *py--);
00471
00472 /* Decrement the loop counter */
00473 k--;
00474 }
00475
00476 /* Store the result in the accumulator in the destination buffer. */
00477 *pOut++ = (q15_t) (__SSAT(sum >> 15, 16));
00478
00479 /* Update the inputA and inputB pointers for next MAC calculation */
00480 px = pIn1 + count;
00481 py = pSrc2;
00482
00483 /* Increment the pointer pIn1 index, count by 1 */
00484 count++;
00485
00486 /* Decrement the loop counter */
00487 blkCnt--;
00488 }
00489 }
00490 else
00491 {
00492 /* If the srcBLen is not a multiple of 4,
00493 * the blockSize2 loop cannot be unrolled by 4 */
00494 blkCnt = blockSize2;
00495
00496 while(blkCnt > 0u)
00497 {
00498 /* Accumulator is made zero for every iteration */
00499 sum = 0;
00500
00501 /* srcBLen number of MACS should be performed */
00502 k = srcBLen;
00503
00504 while(k > 0u)
00505 {
00506 /* Perform the multiply-accumulate */
00507 sum += (q63_t) ((q31_t) * px++ * *py--);
00508
00509 /* Decrement the loop counter */
00510 k--;
00511 }
00512
00513 /* Store the result in the accumulator in the destination buffer. */
00514 *pOut++ = (q15_t) (__SSAT(sum >> 15, 16));
00515
00516 /* Update the inputA and inputB pointers for next MAC calculation */
00517 px = pIn1 + count;
00518 py = pSrc2;
00519
00520 /* Increment the MAC count */
00521 count++;
00522
00523 /* Decrement the loop counter */
00524 blkCnt--;
00525 }
00526 }
00527
00528
00529 /* --------------------------
00530 * Initializations of stage3
00531 * -------------------------*/
00532
00533 /* sum += x[srcALen-srcBLen+1] * y[srcBLen-1] + x[srcALen-srcBLen+2] * y[srcBLen-2] +...+ x[srcALen-1] * y[1]
00534 * sum += x[srcALen-srcBLen+2] * y[srcBLen-1] + x[srcALen-srcBLen+3] * y[srcBLen-2] +...+ x[srcALen-1] * y[2]
00535 * ....
00536 * sum += x[srcALen-2] * y[srcBLen-1] + x[srcALen-1] * y[srcBLen-2]
00537 * sum += x[srcALen-1] * y[srcBLen-1]
00538 */
00539
00540 /* In this stage the MAC operations are decreased by 1 for every iteration.
00541 The blockSize3 variable holds the number of MAC operations performed */
00542
00543 blockSize3 = srcBLen - 1u;
00544
00545 /* Working pointer of inputA */
00546 pSrc1 = (pIn1 + srcALen) - (srcBLen - 1u);
00547 px = pSrc1;
00548
00549 /* Working pointer of inputB */
00550 pSrc2 = pIn2 + (srcBLen - 1u);
00551 pIn2 = pSrc2 - 1u;
00552 py = pIn2;
00553
00554 /* -------------------
00555 * Stage3 process
00556 * ------------------*/
00557
00558 /* For loop unrolling by 4, this stage is divided into two. */
00559 /* First part of this stage computes the MAC operations greater than 4 */
00560 /* Second part of this stage computes the MAC operations less than or equal to 4 */
00561
00562 /* The first part of the stage starts here */
00563 j = blockSize3 >> 2u;
00564
00565 while((j > 0u) && (blockSize3 > 0u))
00566 {
00567 /* Accumulator is made zero for every iteration */
00568 sum = 0;
00569
00570 /* Apply loop unrolling and compute 4 MACs simultaneously. */
00571 k = blockSize3 >> 2u;
00572
00573 /* First part of the processing with loop unrolling. Compute 4 MACs at a time.
00574 ** a second loop below computes MACs for the remaining 1 to 3 samples. */
00575 while(k > 0u)
00576 {
00577 /* x[srcALen - srcBLen + 1], x[srcALen - srcBLen + 2] are multiplied
00578 * with y[srcBLen - 1], y[srcBLen - 2] respectively */
00579 sum = __SMLALDX(*__SIMD32(px)++, *__SIMD32(py)--, sum);
00580 /* x[srcALen - srcBLen + 3], x[srcALen - srcBLen + 4] are multiplied
00581 * with y[srcBLen - 3], y[srcBLen - 4] respectively */
00582 sum = __SMLALDX(*__SIMD32(px)++, *__SIMD32(py)--, sum);
00583
00584 /* Decrement the loop counter */
00585 k--;
00586 }
00587
00588 /* For the next MAC operations, the pointer py is used without SIMD
00589 * So, py is incremented by 1 */
00590 py = py + 1u;
00591
00592 /* If the blockSize3 is not a multiple of 4, compute any remaining MACs here.
00593 ** No loop unrolling is used. */
00594 k = blockSize3 % 0x4u;
00595
00596 while(k > 0u)
00597 {
00598 /* sum += x[srcALen - srcBLen + 5] * y[srcBLen - 5] */
00599 sum = __SMLALD(*px++, *py--, sum);
00600
00601 /* Decrement the loop counter */
00602 k--;
00603 }
00604
00605 /* Store the result in the accumulator in the destination buffer. */
00606 *pOut++ = (q15_t) (__SSAT((sum >> 15), 16));
00607
00608 /* Update the inputA and inputB pointers for next MAC calculation */
00609 px = ++pSrc1;
00610 py = pIn2;
00611
00612 /* Decrement the loop counter */
00613 blockSize3--;
00614
00615 j--;
00616 }
00617
00618 /* The second part of the stage starts here */
00619 /* SIMD is not used for the next MAC operations,
00620 * so pointer py is updated to read only one sample at a time */
00621 py = py + 1u;
00622
00623 while(blockSize3 > 0u)
00624 {
00625 /* Accumulator is made zero for every iteration */
00626 sum = 0;
00627
00628 /* Apply loop unrolling and compute 4 MACs simultaneously. */
00629 k = blockSize3;
00630
00631 while(k > 0u)
00632 {
00633 /* Perform the multiply-accumulates */
00634 /* sum += x[srcALen-1] * y[srcBLen-1] */
00635 sum = __SMLALD(*px++, *py--, sum);
00636
00637 /* Decrement the loop counter */
00638 k--;
00639 }
00640
00641 /* Store the result in the accumulator in the destination buffer. */
00642 *pOut++ = (q15_t) (__SSAT((sum >> 15), 16));
00643
00644 /* Update the inputA and inputB pointers for next MAC calculation */
00645 px = ++pSrc1;
00646 py = pSrc2;
00647
00648 /* Decrement the loop counter */
00649 blockSize3--;
00650 }
00651
00652 }
00653
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines
Generated on Mon Nov 29 2010 17:19:56 for CMSIS DSP Software Library by
1.7.2
Wyszukiwarka
Podobne podstrony:
arm conv ?2? sourcearm shift q15? sourcearm scale q15? sourcearm sin q15? sourcearm rms q15? sourcearm mult q15? sourcearm sub q15? sourcearm conv q15?arm copy q15? sourcearm min q15? sourcearm std q15? sourcearm conv q7? sourcearm ?s q15? sourcearm var q15? sourcearm negate q15? sourcearm conv q31? sourcearm ?t4 q15? sourcearm lms q15? sourcearm fill q15? sourcewięcej podobnych podstron