arm_conv_partial_fast_q15.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_conv_partial_fast_q15.c 00009 * 00010 * Description: Fast Q15 Partial convolution. 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 #include "arm_math.h" 00025 00059 #ifndef UNALIGNED_SUPPORT_DISABLE 00060 00061 arm_status arm_conv_partial_fast_q15( 00062 q15_t * pSrcA, 00063 uint32_t srcALen, 00064 q15_t * pSrcB, 00065 uint32_t srcBLen, 00066 q15_t * pDst, 00067 uint32_t firstIndex, 00068 uint32_t numPoints, 00069 q15_t * pScratch1, 00070 q15_t *pScratch2) 00071 { 00072 00073 q15_t *pOut = pDst; /* output pointer */ 00074 q15_t *pScr1 = pScratch1; /* Temporary pointer for scratch1 */ 00075 q15_t *pScr2 = pScratch2; /* Temporary pointer for scratch1 */ 00076 q31_t acc0, acc1, acc2, acc3; /* Accumulator */ 00077 q31_t x1, x2, x3; /* Temporary variables to hold state and coefficient values */ 00078 q31_t y1, y2; /* State variables */ 00079 q15_t *pIn1; /* inputA pointer */ 00080 q15_t *pIn2; /* inputB pointer */ 00081 q15_t *px; /* Intermediate inputA pointer */ 00082 q15_t *py; /* Intermediate inputB pointer */ 00083 uint32_t j, k, blkCnt; /* loop counter */ 00084 arm_status status; 00085 00086 uint32_t tapCnt; /* loop count */ 00087 /* Check for range of output samples to be calculated */ 00088 if((firstIndex + numPoints) > ((srcALen + (srcBLen - 1u)))) 00089 { 00090 /* Set status as ARM_MATH_ARGUMENT_ERROR */ 00091 status = ARM_MATH_ARGUMENT_ERROR; 00092 } 00093 else 00094 { 00095 00096 /* The algorithm implementation is based on the lengths of the inputs. */ 00097 /* srcB is always made to slide across srcA. */ 00098 /* So srcBLen is always considered as shorter or equal to srcALen */ 00099 if(srcALen >= srcBLen) 00100 { 00101 /* Initialization of inputA pointer */ 00102 pIn1 = pSrcA; 00103 00104 /* Initialization of inputB pointer */ 00105 pIn2 = pSrcB; 00106 } 00107 else 00108 { 00109 /* Initialization of inputA pointer */ 00110 pIn1 = pSrcB; 00111 00112 /* Initialization of inputB pointer */ 00113 pIn2 = pSrcA; 00114 00115 /* srcBLen is always considered as shorter or equal to srcALen */ 00116 j = srcBLen; 00117 srcBLen = srcALen; 00118 srcALen = j; 00119 } 00120 00121 /* Temporary pointer for scratch2 */ 00122 py = pScratch2; 00123 00124 /* pointer to take end of scratch2 buffer */ 00125 pScr2 = pScratch2 + srcBLen - 1; 00126 00127 /* points to smaller length sequence */ 00128 px = pIn2; 00129 00130 /* Apply loop unrolling and do 4 Copies simultaneously. */ 00131 k = srcBLen >> 2u; 00132 00133 /* First part of the processing with loop unrolling copies 4 data points at a time. 00134 ** a second loop below copies for the remaining 1 to 3 samples. */ 00135 00136 /* Copy smaller length input sequence in reverse order into second scratch buffer */ 00137 while(k > 0u) 00138 { 00139 /* copy second buffer in reversal manner */ 00140 *pScr2-- = *px++; 00141 *pScr2-- = *px++; 00142 *pScr2-- = *px++; 00143 *pScr2-- = *px++; 00144 00145 /* Decrement the loop counter */ 00146 k--; 00147 } 00148 00149 /* If the count is not a multiple of 4, copy remaining samples here. 00150 ** No loop unrolling is used. */ 00151 k = srcBLen % 0x4u; 00152 00153 while(k > 0u) 00154 { 00155 /* copy second buffer in reversal manner for remaining samples */ 00156 *pScr2-- = *px++; 00157 00158 /* Decrement the loop counter */ 00159 k--; 00160 } 00161 00162 /* Initialze temporary scratch pointer */ 00163 pScr1 = pScratch1; 00164 00165 /* Assuming scratch1 buffer is aligned by 32-bit */ 00166 /* Fill (srcBLen - 1u) zeros in scratch buffer */ 00167 arm_fill_q15(0, pScr1, (srcBLen - 1u)); 00168 00169 /* Update temporary scratch pointer */ 00170 pScr1 += (srcBLen - 1u); 00171 00172 /* Copy bigger length sequence(srcALen) samples in scratch1 buffer */ 00173 00174 /* Copy (srcALen) samples in scratch buffer */ 00175 arm_copy_q15(pIn1, pScr1, srcALen); 00176 00177 /* Update pointers */ 00178 pScr1 += srcALen; 00179 00180 /* Fill (srcBLen - 1u) zeros at end of scratch buffer */ 00181 arm_fill_q15(0, pScr1, (srcBLen - 1u)); 00182 00183 /* Update pointer */ 00184 pScr1 += (srcBLen - 1u); 00185 00186 /* Initialization of pIn2 pointer */ 00187 pIn2 = py; 00188 00189 pScratch1 += firstIndex; 00190 00191 pOut = pDst + firstIndex; 00192 00193 /* First part of the processing with loop unrolling process 4 data points at a time. 00194 ** a second loop below process for the remaining 1 to 3 samples. */ 00195 00196 /* Actual convolution process starts here */ 00197 blkCnt = (numPoints) >> 2; 00198 00199 while(blkCnt > 0) 00200 { 00201 /* Initialze temporary scratch pointer as scratch1 */ 00202 pScr1 = pScratch1; 00203 00204 /* Clear Accumlators */ 00205 acc0 = 0; 00206 acc1 = 0; 00207 acc2 = 0; 00208 acc3 = 0; 00209 00210 /* Read two samples from scratch1 buffer */ 00211 x1 = *__SIMD32(pScr1)++; 00212 00213 /* Read next two samples from scratch1 buffer */ 00214 x2 = *__SIMD32(pScr1)++; 00215 00216 tapCnt = (srcBLen) >> 2u; 00217 00218 while(tapCnt > 0u) 00219 { 00220 00221 /* Read four samples from smaller buffer */ 00222 y1 = _SIMD32_OFFSET(pIn2); 00223 y2 = _SIMD32_OFFSET(pIn2 + 2u); 00224 00225 /* multiply and accumlate */ 00226 acc0 = __SMLAD(x1, y1, acc0); 00227 acc2 = __SMLAD(x2, y1, acc2); 00228 00229 /* pack input data */ 00230 #ifndef ARM_MATH_BIG_ENDIAN 00231 x3 = __PKHBT(x2, x1, 0); 00232 #else 00233 x3 = __PKHBT(x1, x2, 0); 00234 #endif 00235 00236 /* multiply and accumlate */ 00237 acc1 = __SMLADX(x3, y1, acc1); 00238 00239 /* Read next two samples from scratch1 buffer */ 00240 x1 = _SIMD32_OFFSET(pScr1); 00241 00242 /* multiply and accumlate */ 00243 acc0 = __SMLAD(x2, y2, acc0); 00244 00245 acc2 = __SMLAD(x1, y2, acc2); 00246 00247 /* pack input data */ 00248 #ifndef ARM_MATH_BIG_ENDIAN 00249 x3 = __PKHBT(x1, x2, 0); 00250 #else 00251 x3 = __PKHBT(x2, x1, 0); 00252 #endif 00253 00254 acc3 = __SMLADX(x3, y1, acc3); 00255 acc1 = __SMLADX(x3, y2, acc1); 00256 00257 x2 = _SIMD32_OFFSET(pScr1 + 2u); 00258 00259 #ifndef ARM_MATH_BIG_ENDIAN 00260 x3 = __PKHBT(x2, x1, 0); 00261 #else 00262 x3 = __PKHBT(x1, x2, 0); 00263 #endif 00264 00265 acc3 = __SMLADX(x3, y2, acc3); 00266 00267 /* update scratch pointers */ 00268 pIn2 += 4u; 00269 pScr1 += 4u; 00270 00271 00272 /* Decrement the loop counter */ 00273 tapCnt--; 00274 } 00275 00276 /* Update scratch pointer for remaining samples of smaller length sequence */ 00277 pScr1 -= 4u; 00278 00279 /* apply same above for remaining samples of smaller length sequence */ 00280 tapCnt = (srcBLen) & 3u; 00281 00282 while(tapCnt > 0u) 00283 { 00284 00285 /* accumlate the results */ 00286 acc0 += (*pScr1++ * *pIn2); 00287 acc1 += (*pScr1++ * *pIn2); 00288 acc2 += (*pScr1++ * *pIn2); 00289 acc3 += (*pScr1++ * *pIn2++); 00290 00291 pScr1 -= 3u; 00292 00293 /* Decrement the loop counter */ 00294 tapCnt--; 00295 } 00296 00297 blkCnt--; 00298 00299 00300 /* Store the results in the accumulators in the destination buffer. */ 00301 00302 #ifndef ARM_MATH_BIG_ENDIAN 00303 00304 #ifdef CCS 00305 *__SIMD32(pOut)++ = 00306 __PKHBT(__SSATA(acc0, 15, 16), __SSATA(acc1, 15, 16), 16); 00307 *__SIMD32(pOut)++ = 00308 __PKHBT(__SSATA(acc2, 15, 16), __SSATA(acc3, 15, 16), 16); 00309 #else 00310 *__SIMD32(pOut)++ = 00311 __PKHBT(__SSAT((acc0 >> 15), 16), __SSAT((acc1 >> 15), 16), 16); 00312 *__SIMD32(pOut)++ = 00313 __PKHBT(__SSAT((acc2 >> 15), 16), __SSAT((acc3 >> 15), 16), 16); 00314 #endif 00315 00316 #else 00317 00318 #ifdef CCS 00319 *__SIMD32(pOut)++ = 00320 __PKHBT(__SSATA(acc1, 15, 16), __SSATA(acc0, 15, 16), 16); 00321 *__SIMD32(pOut)++ = 00322 __PKHBT(__SSATA(acc3, 15, 16), __SSATA(acc2, 15, 16), 16); 00323 00324 #else 00325 *__SIMD32(pOut)++ = 00326 __PKHBT(__SSAT((acc1 >> 15), 16), __SSAT((acc0 >> 15), 16), 16); 00327 *__SIMD32(pOut)++ = 00328 __PKHBT(__SSAT((acc3 >> 15), 16), __SSAT((acc2 >> 15), 16), 16); 00329 #endif 00330 00331 #endif /* #ifndef ARM_MATH_BIG_ENDIAN */ 00332 00333 /* Initialization of inputB pointer */ 00334 pIn2 = py; 00335 00336 pScratch1 += 4u; 00337 00338 } 00339 00340 00341 blkCnt = numPoints & 0x3; 00342 00343 /* Calculate convolution for remaining samples of Bigger length sequence */ 00344 while(blkCnt > 0) 00345 { 00346 /* Initialze temporary scratch pointer as scratch1 */ 00347 pScr1 = pScratch1; 00348 00349 /* Clear Accumlators */ 00350 acc0 = 0; 00351 00352 tapCnt = (srcBLen) >> 1u; 00353 00354 while(tapCnt > 0u) 00355 { 00356 00357 /* Read next two samples from scratch1 buffer */ 00358 x1 = *__SIMD32(pScr1)++; 00359 00360 /* Read two samples from smaller buffer */ 00361 y1 = *__SIMD32(pIn2)++; 00362 00363 acc0 = __SMLAD(x1, y1, acc0); 00364 00365 /* Decrement the loop counter */ 00366 tapCnt--; 00367 } 00368 00369 tapCnt = (srcBLen) & 1u; 00370 00371 /* apply same above for remaining samples of smaller length sequence */ 00372 while(tapCnt > 0u) 00373 { 00374 00375 /* accumlate the results */ 00376 acc0 += (*pScr1++ * *pIn2++); 00377 00378 /* Decrement the loop counter */ 00379 tapCnt--; 00380 } 00381 00382 blkCnt--; 00383 00384 /* The result is in 2.30 format. Convert to 1.15 with saturation. 00385 ** Then store the output in the destination buffer. */ 00386 #ifdef CCS 00387 *pOut++ = (q15_t) (__SSATA(acc0, 15, 16)); 00388 #else 00389 *pOut++ = (q15_t) (__SSAT((acc0 >> 15), 16)); 00390 #endif 00391 00392 00393 /* Initialization of inputB pointer */ 00394 pIn2 = py; 00395 00396 pScratch1 += 1u; 00397 00398 } 00399 /* set status as ARM_MATH_SUCCESS */ 00400 status = ARM_MATH_SUCCESS; 00401 } 00402 /* Return to application */ 00403 return (status); 00404 } 00405 00406 #else 00407 00408 arm_status arm_conv_partial_fast_q15( 00409 q15_t * pSrcA, 00410 uint32_t srcALen, 00411 q15_t * pSrcB, 00412 uint32_t srcBLen, 00413 q15_t * pDst, 00414 uint32_t firstIndex, 00415 uint32_t numPoints, 00416 q15_t * pScratch1, 00417 q15_t *pScratch2) 00418 { 00419 00420 q15_t *pOut = pDst; /* output pointer */ 00421 q15_t *pScr1 = pScratch1; /* Temporary pointer for scratch1 */ 00422 q15_t *pScr2 = pScratch2; /* Temporary pointer for scratch1 */ 00423 q31_t acc0, acc1, acc2, acc3; /* Accumulator */ 00424 q15_t *pIn1; /* inputA pointer */ 00425 q15_t *pIn2; /* inputB pointer */ 00426 q15_t *px; /* Intermediate inputA pointer */ 00427 q15_t *py; /* Intermediate inputB pointer */ 00428 uint32_t j, k, blkCnt; /* loop counter */ 00429 arm_status status; /* Status variable */ 00430 uint32_t tapCnt; /* loop count */ 00431 q15_t x10, x11, x20, x21; /* Temporary variables to hold srcA buffer */ 00432 q15_t y10, y11; /* Temporary variables to hold srcB buffer */ 00433 00434 00435 /* Check for range of output samples to be calculated */ 00436 if((firstIndex + numPoints) > ((srcALen + (srcBLen - 1u)))) 00437 { 00438 /* Set status as ARM_MATH_ARGUMENT_ERROR */ 00439 status = ARM_MATH_ARGUMENT_ERROR; 00440 } 00441 else 00442 { 00443 00444 /* The algorithm implementation is based on the lengths of the inputs. */ 00445 /* srcB is always made to slide across srcA. */ 00446 /* So srcBLen is always considered as shorter or equal to srcALen */ 00447 if(srcALen >= srcBLen) 00448 { 00449 /* Initialization of inputA pointer */ 00450 pIn1 = pSrcA; 00451 00452 /* Initialization of inputB pointer */ 00453 pIn2 = pSrcB; 00454 } 00455 else 00456 { 00457 /* Initialization of inputA pointer */ 00458 pIn1 = pSrcB; 00459 00460 /* Initialization of inputB pointer */ 00461 pIn2 = pSrcA; 00462 00463 /* srcBLen is always considered as shorter or equal to srcALen */ 00464 j = srcBLen; 00465 srcBLen = srcALen; 00466 srcALen = j; 00467 } 00468 00469 /* Temporary pointer for scratch2 */ 00470 py = pScratch2; 00471 00472 /* pointer to take end of scratch2 buffer */ 00473 pScr2 = pScratch2 + srcBLen - 1; 00474 00475 /* points to smaller length sequence */ 00476 px = pIn2; 00477 00478 /* Apply loop unrolling and do 4 Copies simultaneously. */ 00479 k = srcBLen >> 2u; 00480 00481 /* First part of the processing with loop unrolling copies 4 data points at a time. 00482 ** a second loop below copies for the remaining 1 to 3 samples. */ 00483 while(k > 0u) 00484 { 00485 /* copy second buffer in reversal manner */ 00486 *pScr2-- = *px++; 00487 *pScr2-- = *px++; 00488 *pScr2-- = *px++; 00489 *pScr2-- = *px++; 00490 00491 /* Decrement the loop counter */ 00492 k--; 00493 } 00494 00495 /* If the count is not a multiple of 4, copy remaining samples here. 00496 ** No loop unrolling is used. */ 00497 k = srcBLen % 0x4u; 00498 00499 while(k > 0u) 00500 { 00501 /* copy second buffer in reversal manner for remaining samples */ 00502 *pScr2-- = *px++; 00503 00504 /* Decrement the loop counter */ 00505 k--; 00506 } 00507 00508 /* Initialze temporary scratch pointer */ 00509 pScr1 = pScratch1; 00510 00511 /* Fill (srcBLen - 1u) zeros in scratch buffer */ 00512 arm_fill_q15(0, pScr1, (srcBLen - 1u)); 00513 00514 /* Update temporary scratch pointer */ 00515 pScr1 += (srcBLen - 1u); 00516 00517 /* Copy bigger length sequence(srcALen) samples in scratch1 buffer */ 00518 00519 00520 /* Apply loop unrolling and do 4 Copies simultaneously. */ 00521 k = srcALen >> 2u; 00522 00523 /* First part of the processing with loop unrolling copies 4 data points at a time. 00524 ** a second loop below copies for the remaining 1 to 3 samples. */ 00525 while(k > 0u) 00526 { 00527 /* copy second buffer in reversal manner */ 00528 *pScr1++ = *pIn1++; 00529 *pScr1++ = *pIn1++; 00530 *pScr1++ = *pIn1++; 00531 *pScr1++ = *pIn1++; 00532 00533 /* Decrement the loop counter */ 00534 k--; 00535 } 00536 00537 /* If the count is not a multiple of 4, copy remaining samples here. 00538 ** No loop unrolling is used. */ 00539 k = srcALen % 0x4u; 00540 00541 while(k > 0u) 00542 { 00543 /* copy second buffer in reversal manner for remaining samples */ 00544 *pScr1++ = *pIn1++; 00545 00546 /* Decrement the loop counter */ 00547 k--; 00548 } 00549 00550 00551 /* Apply loop unrolling and do 4 Copies simultaneously. */ 00552 k = (srcBLen - 1u) >> 2u; 00553 00554 /* First part of the processing with loop unrolling copies 4 data points at a time. 00555 ** a second loop below copies for the remaining 1 to 3 samples. */ 00556 while(k > 0u) 00557 { 00558 /* copy second buffer in reversal manner */ 00559 *pScr1++ = 0; 00560 *pScr1++ = 0; 00561 *pScr1++ = 0; 00562 *pScr1++ = 0; 00563 00564 /* Decrement the loop counter */ 00565 k--; 00566 } 00567 00568 /* If the count is not a multiple of 4, copy remaining samples here. 00569 ** No loop unrolling is used. */ 00570 k = (srcBLen - 1u) % 0x4u; 00571 00572 while(k > 0u) 00573 { 00574 /* copy second buffer in reversal manner for remaining samples */ 00575 *pScr1++ = 0; 00576 00577 /* Decrement the loop counter */ 00578 k--; 00579 } 00580 00581 00582 /* Initialization of pIn2 pointer */ 00583 pIn2 = py; 00584 00585 pScratch1 += firstIndex; 00586 00587 pOut = pDst + firstIndex; 00588 00589 /* Actual convolution process starts here */ 00590 blkCnt = (numPoints) >> 2; 00591 00592 while(blkCnt > 0) 00593 { 00594 /* Initialze temporary scratch pointer as scratch1 */ 00595 pScr1 = pScratch1; 00596 00597 /* Clear Accumlators */ 00598 acc0 = 0; 00599 acc1 = 0; 00600 acc2 = 0; 00601 acc3 = 0; 00602 00603 /* Read two samples from scratch1 buffer */ 00604 x10 = *pScr1++; 00605 x11 = *pScr1++; 00606 00607 /* Read next two samples from scratch1 buffer */ 00608 x20 = *pScr1++; 00609 x21 = *pScr1++; 00610 00611 tapCnt = (srcBLen) >> 2u; 00612 00613 while(tapCnt > 0u) 00614 { 00615 00616 /* Read two samples from smaller buffer */ 00617 y10 = *pIn2; 00618 y11 = *(pIn2 + 1u); 00619 00620 /* multiply and accumlate */ 00621 acc0 += (q31_t) x10 * y10; 00622 acc0 += (q31_t) x11 * y11; 00623 acc2 += (q31_t) x20 * y10; 00624 acc2 += (q31_t) x21 * y11; 00625 00626 /* multiply and accumlate */ 00627 acc1 += (q31_t) x11 * y10; 00628 acc1 += (q31_t) x20 * y11; 00629 00630 /* Read next two samples from scratch1 buffer */ 00631 x10 = *pScr1; 00632 x11 = *(pScr1 + 1u); 00633 00634 /* multiply and accumlate */ 00635 acc3 += (q31_t) x21 * y10; 00636 acc3 += (q31_t) x10 * y11; 00637 00638 /* Read next two samples from scratch2 buffer */ 00639 y10 = *(pIn2 + 2u); 00640 y11 = *(pIn2 + 3u); 00641 00642 /* multiply and accumlate */ 00643 acc0 += (q31_t) x20 * y10; 00644 acc0 += (q31_t) x21 * y11; 00645 acc2 += (q31_t) x10 * y10; 00646 acc2 += (q31_t) x11 * y11; 00647 acc1 += (q31_t) x21 * y10; 00648 acc1 += (q31_t) x10 * y11; 00649 00650 /* Read next two samples from scratch1 buffer */ 00651 x20 = *(pScr1 + 2); 00652 x21 = *(pScr1 + 3); 00653 00654 /* multiply and accumlate */ 00655 acc3 += (q31_t) x11 * y10; 00656 acc3 += (q31_t) x20 * y11; 00657 00658 /* update scratch pointers */ 00659 pIn2 += 4u; 00660 pScr1 += 4u; 00661 00662 /* Decrement the loop counter */ 00663 tapCnt--; 00664 } 00665 00666 /* Update scratch pointer for remaining samples of smaller length sequence */ 00667 pScr1 -= 4u; 00668 00669 /* apply same above for remaining samples of smaller length sequence */ 00670 tapCnt = (srcBLen) & 3u; 00671 00672 while(tapCnt > 0u) 00673 { 00674 /* accumlate the results */ 00675 acc0 += (*pScr1++ * *pIn2); 00676 acc1 += (*pScr1++ * *pIn2); 00677 acc2 += (*pScr1++ * *pIn2); 00678 acc3 += (*pScr1++ * *pIn2++); 00679 00680 pScr1 -= 3u; 00681 00682 /* Decrement the loop counter */ 00683 tapCnt--; 00684 } 00685 00686 blkCnt--; 00687 00688 00689 /* Store the results in the accumulators in the destination buffer. */ 00690 #ifdef CCS 00691 *pOut++ = __SSATA(acc0, 15, 16); 00692 *pOut++ = __SSATA(acc1, 15, 16); 00693 *pOut++ = __SSATA(acc2, 15, 16); 00694 *pOut++ = __SSATA(acc3, 15, 16); 00695 #else 00696 *pOut++ = __SSAT((acc0 >> 15), 16); 00697 *pOut++ = __SSAT((acc1 >> 15), 16); 00698 *pOut++ = __SSAT((acc2 >> 15), 16); 00699 *pOut++ = __SSAT((acc3 >> 15), 16); 00700 #endif 00701 00702 /* Initialization of inputB pointer */ 00703 pIn2 = py; 00704 00705 pScratch1 += 4u; 00706 00707 } 00708 00709 00710 blkCnt = numPoints & 0x3; 00711 00712 /* Calculate convolution for remaining samples of Bigger length sequence */ 00713 while(blkCnt > 0) 00714 { 00715 /* Initialze temporary scratch pointer as scratch1 */ 00716 pScr1 = pScratch1; 00717 00718 /* Clear Accumlators */ 00719 acc0 = 0; 00720 00721 tapCnt = (srcBLen) >> 1u; 00722 00723 while(tapCnt > 0u) 00724 { 00725 00726 /* Read next two samples from scratch1 buffer */ 00727 x10 = *pScr1++; 00728 x11 = *pScr1++; 00729 00730 /* Read two samples from smaller buffer */ 00731 y10 = *pIn2++; 00732 y11 = *pIn2++; 00733 00734 /* multiply and accumlate */ 00735 acc0 += (q31_t) x10 * y10; 00736 acc0 += (q31_t) x11 * y11; 00737 00738 /* Decrement the loop counter */ 00739 tapCnt--; 00740 } 00741 00742 tapCnt = (srcBLen) & 1u; 00743 00744 /* apply same above for remaining samples of smaller length sequence */ 00745 while(tapCnt > 0u) 00746 { 00747 00748 /* accumlate the results */ 00749 acc0 += (*pScr1++ * *pIn2++); 00750 00751 /* Decrement the loop counter */ 00752 tapCnt--; 00753 } 00754 00755 blkCnt--; 00756 00757 /* Store the result in the accumulator in the destination buffer. */ 00758 #ifdef CCS 00759 *pOut++ = (q15_t) (__SSATA(acc0, 15, 16)); 00760 #else 00761 *pOut++ = (q15_t) (__SSAT((acc0 >> 15), 16)); 00762 #endif 00763 00764 /* Initialization of inputB pointer */ 00765 pIn2 = py; 00766 00767 pScratch1 += 1u; 00768 00769 } 00770 00771 /* set status as ARM_MATH_SUCCESS */ 00772 status = ARM_MATH_SUCCESS; 00773 00774 } 00775 00776 /* Return to application */ 00777 return (status); 00778 } 00779 00780 #endif 00781 00782
