- 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