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

- File List
- Globals

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

All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines