CMSIS-DSP: Added MVE code for FIR.

Improved FIR test patterns.

Include/arm_math.h

@@ -1350,7 +1350,7 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
         /*
          * 64-bit division
          */
-        result = num / den;
+        result = (q31_t) num / den;
 
     return result;
 }
@@ -5548,7 +5548,7 @@ __STATIC_FORCEINLINE q15_t arm_pid_q15(
     acc += (q31_t) S->state[2] << 15;
 
     /* saturate the output */
-    out = (q15_t) (__SSAT((acc >> 15), 16));
+    out = (q15_t) (__SSAT((q31_t)(acc >> 15), 16));
 
     /* Update state */
     S->state[1] = S->state[0];

Source/FilteringFunctions/arm_fir_q15.c

@@ -56,7 +56,471 @@
   @remark
                    Refer to \ref arm_fir_fast_q15() for a faster but less precise implementation of this function.
  */
+#if defined(ARM_MATH_MVEI)
 
+#define MVE_ASRL_SAT16(acc, shift)          ((sqrshrl_sat48(acc, -(32-shift)) >> 32) & 0xffffffff)
+
+static void arm_fir_q15_1_8_mve(const arm_fir_instance_q15 * S, const q15_t * pSrc, q15_t * pDst, uint32_t blockSize)
+{
+    q15_t    *pState = S->pState;   /* State pointer */
+    const q15_t    *pCoeffs = S->pCoeffs; /* Coefficient pointer */
+    q15_t    *pStateCur;        /* Points to the current sample of the state */
+    const q15_t    *pSamples;         /* Temporary pointer to the sample buffer */
+    q15_t    *pOutput;          /* Temporary pointer to the output buffer */
+    const q15_t    *pTempSrc;         /* Temporary pointer to the source data */
+    q15_t    *pTempDest;        /* Temporary pointer to the destination buffer */
+    uint32_t  numTaps = S->numTaps; /* Number of filter coefficients in the filter */
+    uint32_t  blkCnt;
+    q15x8_t vecIn0;
+    /*
+     * load 8 coefs
+     */
+    q15x8_t vecCoeffs = *(q15x8_t *) pCoeffs;
+
+    /*
+     * pState points to state array which contains previous frame (numTaps - 1) samples
+     * pStateCur points to the location where the new input data should be written
+     */
+    pStateCur = &(pState[(numTaps - 1u)]);
+    pTempSrc = pSrc;
+    pSamples = pState;
+    pOutput = pDst;
+
+    q63_t     acc0, acc1, acc2, acc3;
+
+    blkCnt = blockSize >> 2;
+
+    while (blkCnt > 0U)
+    {
+        const q15_t    *pSamplesTmp = pSamples;
+
+        /*
+         * Save 4 input samples in the history buffer
+         */
+        vst1q(pStateCur, vld1q(pTempSrc));
+        pStateCur += 8;
+        pTempSrc += 8;
+
+        vecIn0 = vld1q(pSamplesTmp);
+        acc0 = vmlaldavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamplesTmp[1]);
+        acc1 = vmlaldavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamplesTmp[2]);
+        acc2 = vmlaldavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamplesTmp[3]);
+        acc3 = vmlaldavq(vecIn0, vecCoeffs);
+
+        *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+        *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+        *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc2, 15);
+        *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc3, 15);
+
+        pSamples += 4;
+        /*
+         * Decrement the sample block loop counter
+         */
+        blkCnt--;
+    }
+
+    uint32_t  residual = blockSize & 3;
+    switch (residual)
+    {
+    case 3:
+        {
+            const q15_t    *pSamplesTmp = pSamples;
+
+            acc0 = 0LL;
+            acc1 = 0LL;
+            acc2 = 0LL;
+
+            /*
+             * Save 4 input samples in the history buffer
+             */
+            *(q15x8_t *) pStateCur = *(q15x8_t *) pTempSrc;
+            pStateCur += 8;
+            pTempSrc += 8;
+
+            vecIn0 = vld1q(pSamplesTmp);
+            acc0 = vmlaldavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamplesTmp[1]);
+            acc1 = vmlaldavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamplesTmp[2]);
+            acc2 = vmlaldavq(vecIn0, vecCoeffs);
+
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc2, 15);
+        }
+        break;
+
+    case 2:
+        {
+            const q15_t    *pSamplesTmp = pSamples;
+
+            acc0 = 0LL;
+            acc1 = 0LL;
+
+            /*
+             * Save 4 input samples in the history buffer
+             */
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 8;
+            pTempSrc += 8;
+
+            vecIn0 = vld1q(pSamplesTmp);
+            acc0 = vmlaldavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamplesTmp[1]);
+            acc1 = vmlaldavq(vecIn0, vecCoeffs);
+
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+        }
+        break;
+
+    case 1:
+        {
+            const q15_t    *pSamplesTmp = pSamples;
+
+            acc0 = 0LL;
+
+            /*
+             * Save 4 input samples in the history buffer
+             */
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 8;
+            pTempSrc += 8;
+
+            vecIn0 = vld1q(pSamplesTmp);
+            acc0 = vmlaldavq(vecIn0, vecCoeffs);
+
+            pSamplesTmp += 4;
+
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+        }
+        break;
+    }
+
+    /*
+     * Copy the samples back into the history buffer start
+     */
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
+
+    blkCnt = numTaps >> 3;
+    while (blkCnt > 0U)
+    {
+        vst1q(pTempDest, vld1q(pTempSrc));
+        pTempSrc += 8;
+        pTempDest += 8;
+        blkCnt--;
+    }
+    blkCnt = numTaps & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vstrhq_p_s16(pTempDest, vld1q(pTempSrc), p0);
+    }
+}
+
+void arm_fir_q15(
+  const arm_fir_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize)
+{
+    q15_t    *pState = S->pState;   /* State pointer */
+    const q15_t    *pCoeffs = S->pCoeffs; /* Coefficient pointer */
+    q15_t    *pStateCur;        /* Points to the current sample of the state */
+    const q15_t    *pSamples;         /* Temporary pointer to the sample buffer */
+    q15_t    *pOutput;          /* Temporary pointer to the output buffer */
+    const q15_t    *pTempSrc;         /* Temporary pointer to the source data */
+    q15_t    *pTempDest;        /* Temporary pointer to the destination buffer */
+    uint32_t  numTaps = S->numTaps; /* Number of filter coefficients in the filter */
+    uint32_t  blkCnt;
+    q15x8_t vecIn0;
+    uint32_t  tapsBlkCnt = (numTaps + 7) / 8;
+    q63_t     acc0, acc1, acc2, acc3;
+
+    if (blockSize >= 12)
+    {
+       if(numTaps <= 8) {
+           /* [1 to 8 taps] specialized routine */
+           arm_fir_q15_1_8_mve(S,pSrc, pDst, blockSize);
+           return;
+       }
+    }
+
+    if (blockSize >= 12)
+    {
+        /*
+         * pState points to state array which contains previous frame (numTaps - 1) samples
+         * pStateCur points to the location where the new input data should be written
+         */
+        pStateCur   = &(pState[(numTaps - 1u)]);
+        pTempSrc    = pSrc;
+        pSamples    = pState;
+        pOutput     = pDst;
+        blkCnt      = blockSize >> 2;
+    
+        while (blkCnt > 0U)
+        {
+            const q15_t    *pCoeffsTmp = pCoeffs;
+            const q15_t    *pSamplesTmp = pSamples;
+    
+            acc0 = 0LL;
+            acc1 = 0LL;
+            acc2 = 0LL;
+            acc3 = 0LL;
+    
+            /*
+             * Save 8 input samples in the history buffer
+             */
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 8;
+            pTempSrc += 8;
+    
+            uint32_t       i = tapsBlkCnt;
+            while (i > 0U)
+            {
+                /*
+                 * load 8 coefs
+                 */
+                q15x8_t vecCoeffs = *(q15x8_t *) pCoeffsTmp;
+    
+                vecIn0 = vld1q(pSamplesTmp);
+                acc0 =  vmlaldavaq(acc0, vecIn0, vecCoeffs);
+    
+                vecIn0 = vld1q(&pSamplesTmp[1]);
+                acc1 = vmlaldavaq(acc1, vecIn0, vecCoeffs);
+    
+                vecIn0 = vld1q(&pSamplesTmp[2]);
+                acc2 = vmlaldavaq(acc2, vecIn0, vecCoeffs);
+    
+                vecIn0 = vld1q(&pSamplesTmp[3]);
+                acc3 = vmlaldavaq(acc3, vecIn0, vecCoeffs);
+    
+                pSamplesTmp += 8;
+                pCoeffsTmp += 8;
+                /*
+                 * Decrement the taps block loop counter
+                 */
+                i--;
+            }
+    
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc2, 15);
+            *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc3, 15);
+    
+            pSamples += 4;
+            /*
+             * Decrement the sample block loop counter
+             */
+            blkCnt--;
+        }
+    
+        uint32_t  residual = blockSize & 3;
+        switch (residual)
+        {
+        case 3:
+            {
+                const q15_t    *pCoeffsTmp = pCoeffs;
+                const q15_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+                acc1 = 0LL;
+                acc2 = 0LL;
+    
+                /*
+                 * Save 8 input samples in the history buffer
+                 */
+                *(q15x8_t *) pStateCur = *(q15x8_t *) pTempSrc;
+                pStateCur += 8;
+                pTempSrc += 8;
+    
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    /*
+                     * load 8 coefs
+                     */
+                    q15x8_t vecCoeffs = *(q15x8_t *) pCoeffsTmp;
+    
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vmlaldavaq(acc0, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[1]);
+                    acc1 = vmlaldavaq(acc1, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[2]);
+                    acc2 = vmlaldavaq(acc2, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 8;
+                    pCoeffsTmp += 8;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+              
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc2, 15);
+            }
+            break;
+    
+        case 2:
+            {
+                const q15_t    *pCoeffsTmp = pCoeffs;
+                const q15_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+                acc1 = 0LL;
+                /*
+                 * Save 8 input samples in the history buffer
+                 */
+                vst1q(pStateCur, vld1q(pTempSrc));
+                pStateCur += 8;
+                pTempSrc += 8;
+    
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    /*
+                     * load 8 coefs
+                     */
+                    q15x8_t vecCoeffs = *(q15x8_t *) pCoeffsTmp;
+    
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vmlaldavaq(acc0, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[1]);
+                    acc1 = vmlaldavaq(acc1, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 8;
+                    pCoeffsTmp += 8;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc1, 15);
+            }
+            break;
+    
+        case 1:
+            {
+                const q15_t    *pCoeffsTmp = pCoeffs;
+                const q15_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+    
+                /*
+                 * Save 8 input samples in the history buffer
+                 */
+                vst1q(pStateCur, vld1q(pTempSrc));
+                pStateCur += 8;
+                pTempSrc += 8;
+    
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    /*
+                     * load 8 coefs
+                     */
+                    q15x8_t vecCoeffs = *(q15x8_t *) pCoeffsTmp;
+    
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vmlaldavaq(acc0, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 8;
+                    pCoeffsTmp += 8;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+                *pOutput++ = (q15_t) MVE_ASRL_SAT16(acc0, 15);
+            }
+            break;
+        }
+    }
+    else
+    {
+        q15_t *pStateCurnt;                            /* Points to the current sample of the state */
+            q15_t *px;                                     /* Temporary pointer for state buffer */
+      const q15_t *pb;                                     /* Temporary pointer for coefficient buffer */
+            q63_t acc0;                                    /* Accumulator */
+            uint32_t  blkCnt,tapCnt;                    /* Loop counters */
+      pStateCurnt = &(S->pState[(numTaps - 1U)]);
+      blkCnt = blockSize;
+      while (blkCnt > 0U)
+      {
+        /* Copy two samples into state buffer */
+        *pStateCurnt++ = *pSrc++;
+    
+        /* Set the accumulator to zero */
+        acc0 = 0;
+    
+        /* Use SIMD to hold states and coefficients */
+        px = pState;
+        pb = pCoeffs;
+    
+        tapCnt = numTaps >> 1U;
+    
+        while (tapCnt > 0U)
+        {
+          acc0 += (q15_t) *px++ * *pb++;
+          acc0 += (q15_t) *px++ * *pb++;
+    
+          tapCnt--;
+        }
+        
+    
+        /* The result is in 2.30 format. Convert to 1.15 with saturation.
+           Then store the output in the destination buffer. */
+        *pDst++ = (q15_t) (__SSAT((acc0 >> 15), 16));
+    
+        /* Advance state pointer by 1 for the next sample */
+        pState = pState + 1U;
+    
+        /* Decrement loop counter */
+        blkCnt--;
+      }
+    }
+    /*
+     * Copy the samples back into the history buffer start
+     */
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
+
+    blkCnt = numTaps >> 3;
+    while (blkCnt > 0U)
+    {
+        vst1q(pTempDest, vld1q(pTempSrc));
+        pTempSrc += 8;
+        pTempDest += 8;
+        blkCnt--;
+    }
+    blkCnt = numTaps & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vstrhq_p_s16(pTempDest, vld1q(pTempSrc), p0);
+    }
+}
+
+#else
 void arm_fir_q15(
   const arm_fir_instance_q15 * S,
   const q15_t * pSrc,
@@ -326,6 +790,7 @@ void arm_fir_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of FIR group

Source/FilteringFunctions/arm_fir_q31.c

@@ -55,12 +55,11 @@
  @remark
                    Refer to \ref arm_fir_fast_q31() for a faster but less precise implementation of this filter.
  */
-//#if defined(ARM_MATH_MVEI)
-#if 0
-
-/* Work in progress. This MVEI implementation is not yet working */
+#if defined(ARM_MATH_MVEI)
 
 #include "arm_helium_utils.h"
+                                        
+
 
 static void arm_fir_q31_1_4_mve(const arm_fir_instance_q31 * S, const q31_t * pSrc, q31_t * pDst, uint32_t blockSize)
 {
@@ -132,6 +131,7 @@ static void arm_fir_q31_1_4_mve(const arm_fir_instance_q31 * S, const q31_t * pS
     }
 
     uint32_t  residual = blockSize & 3;
+    
     switch (residual)
     {
     case 3:
@@ -139,6 +139,7 @@ static void arm_fir_q31_1_4_mve(const arm_fir_instance_q31 * S, const q31_t * pS
             /*
              * Save 4 input samples in the history buffer
              */
+
             *(q31x4_t *) pStateCur = *(q31x4_t *) pTempSrc;
             pStateCur += 4;
             pTempSrc += 4;
@@ -204,11 +205,12 @@ static void arm_fir_q31_1_4_mve(const arm_fir_instance_q31 * S, const q31_t * pS
         break;
     }
 
+
     /*
      * Copy the samples back into the history buffer start
      */
-    pTempSrc = &pState[blockSize];
-    pTempDest = pState;
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
 
     blkCnt = numTaps >> 2;
     while (blkCnt > 0U)
@@ -333,13 +335,13 @@ static void arm_fir_q31_5_8_mve(const arm_fir_instance_q31 * S, const q31_t * pS
             vecIn0 = vld1q(&pSamples[2]);
             acc2 = vrmlaldavhq(vecIn0, vecCoeffs1_4);
 
-            vecIn0 = vld1q(&pSamples[3]);
+            vecIn0 = vld1q(&pSamples[4]);
             acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs5_8);
 
-            vecIn0 = vld1q(&pSamples[4]);
+            vecIn0 = vld1q(&pSamples[5]);
             acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs5_8);
 
-            vecIn0 = vld1q(&pSamples[5]);
+            vecIn0 = vld1q(&pSamples[6]);
             acc2 = vrmlaldavhaq(acc2, vecIn0, vecCoeffs5_8);
 
             acc0 = asrl(acc0, 23);
@@ -406,8 +408,8 @@ static void arm_fir_q31_5_8_mve(const arm_fir_instance_q31 * S, const q31_t * pS
     /*
      * Copy the samples back into the history buffer start
      */
-    pTempSrc = &pState[blockSize];
-    pTempDest = pState;
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
 
     blkCnt = numTaps >> 2;
     while (blkCnt > 0U)
@@ -448,216 +450,354 @@ void arm_fir_q31(
     /*
      * [1 to 8 taps] specialized routines
      */
-    if (numTaps <= 4)
-    {
-        arm_fir_q31_1_4_mve(S, pSrc, pDst, blockSize);
-        return;
-    }
-    else if (numTaps <= 8)
+    
+    if (blockSize >= 8)
     {
-        arm_fir_q31_5_8_mve(S, pSrc, pDst, blockSize);
-        return;
+        if (numTaps <= 4)
+        {
+            arm_fir_q31_1_4_mve(S, pSrc, pDst, blockSize);
+            return;
+        }
+        else if (numTaps <= 8)
+        {
+            arm_fir_q31_5_8_mve(S, pSrc, pDst, blockSize);
+            return;
+        }
     }
 
+
     /*
      * pState points to state array which contains previous frame (numTaps - 1) samples
      * pStateCur points to the location where the new input data should be written
      */
-    pStateCur   = &(pState[(numTaps - 1u)]);
-    pSamples    = pState;
-    pTempSrc    = pSrc;
-    pOutput     = pDst;
-    blkCnt      = blockSize >> 2;
-    while (blkCnt > 0U)
+    if (blockSize >= 8)
     {
-        const q31_t    *pCoeffsTmp = pCoeffs;
-        const q31_t    *pSamplesTmp = pSamples;
-
-        acc0 = 0LL;
-        acc1 = 0LL;
-        acc2 = 0LL;
-        acc3 = 0LL;
-
-        /*
-         * Save 4 input samples in the history buffer
-         */
-        vst1q(pStateCur, vld1q(pTempSrc));
-        pStateCur += 4;
-        pTempSrc += 4;
-
-        uint32_t       i = tapsBlkCnt;
-        while (i > 0U)
-        {
-            /*
-             * load 4 coefs
-             */
-            vecCoeffs = *(q31x4_t *) pCoeffsTmp;
-
-            vecIn0 = vld1q(pSamplesTmp);
-            acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
-
-            vecIn0 = vld1q(&pSamplesTmp[1]);
-            acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs);
-
-            vecIn0 = vld1q(&pSamplesTmp[2]);
-            acc2 = vrmlaldavhaq(acc2, vecIn0, vecCoeffs);
-
-            vecIn0 = vld1q(&pSamplesTmp[3]);
-            acc3 = vrmlaldavhaq(acc3, vecIn0, vecCoeffs);
-
-            pSamplesTmp += 4;
-            pCoeffsTmp += 4;
-            /*
-             * Decrement the taps block loop counter
-             */
-            i--;
-        }
-
-        /* .54-> .31 conversion and store accumulators */
-        acc0 = asrl(acc0, 23);
-        acc1 = asrl(acc1, 23);
-        acc2 = asrl(acc2, 23);
-        acc3 = asrl(acc3, 23);
-
-        *pOutput++ = (q31_t) acc0;
-        *pOutput++ = (q31_t) acc1;
-        *pOutput++ = (q31_t) acc2;
-        *pOutput++ = (q31_t) acc3;
-
-        pSamples += 4;
-
-        /*
-         * Decrement the sample block loop counter
-         */
-        blkCnt--;
-    }
-
-    uint32_t  residual = blockSize & 3;
-    switch (residual)
-    {
-    case 3:
+        pStateCur   = &(pState[(numTaps - 1u)]);
+        pSamples    = pState;
+        pTempSrc    = pSrc;
+        pOutput     = pDst;
+        blkCnt      = blockSize >> 2;
+        while (blkCnt > 0U)
         {
             const q31_t    *pCoeffsTmp = pCoeffs;
             const q31_t    *pSamplesTmp = pSamples;
-
+    
             acc0 = 0LL;
             acc1 = 0LL;
             acc2 = 0LL;
-
+            acc3 = 0LL;
+    
             /*
              * Save 4 input samples in the history buffer
              */
-            *(q31x4_t *) pStateCur = *(q31x4_t *) pTempSrc;
+            vst1q(pStateCur, vld1q(pTempSrc));
             pStateCur += 4;
             pTempSrc += 4;
-
-            uint32_t       i = tapsBlkCnt;
+    
+            tapsBlkCnt = (numTaps ) / 4;
+            uint32_t       i = tapsBlkCnt ;
             while (i > 0U)
             {
+                /*
+                 * load 4 coefs
+                 */
                 vecCoeffs = *(q31x4_t *) pCoeffsTmp;
-
+    
                 vecIn0 = vld1q(pSamplesTmp);
                 acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
-
+    
                 vecIn0 = vld1q(&pSamplesTmp[1]);
                 acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs);
-
+    
                 vecIn0 = vld1q(&pSamplesTmp[2]);
                 acc2 = vrmlaldavhaq(acc2, vecIn0, vecCoeffs);
-
+    
+                vecIn0 = vld1q(&pSamplesTmp[3]);
+                acc3 = vrmlaldavhaq(acc3, vecIn0, vecCoeffs);
+    
                 pSamplesTmp += 4;
                 pCoeffsTmp += 4;
+                /*
+                 * Decrement the taps block loop counter
+                 */
                 i--;
             }
 
-            acc0 = asrl(acc0, 23);
-            acc1 = asrl(acc1, 23);
-            acc2 = asrl(acc2, 23);
-
-            *pOutput++ = (q31_t) acc0;
-            *pOutput++ = (q31_t) acc1;
-            *pOutput++ = (q31_t) acc2;
-        }
-        break;
-
-    case 2:
-        {
-            const q31_t    *pCoeffsTmp = pCoeffs;
-            const q31_t    *pSamplesTmp = pSamples;
-
-            acc0 = 0LL;
-            acc1 = 0LL;
-
-            /*
-             * Save 4 input samples in the history buffer
-             */
-            vst1q(pStateCur, vld1q(pTempSrc));
-            pStateCur += 4;
-            pTempSrc += 4;
-
-            uint32_t       i = tapsBlkCnt;
+            tapsBlkCnt = (numTaps ) & 3;
+            i = tapsBlkCnt ;
             while (i > 0U)
             {
-                vecCoeffs = *(q31x4_t *) pCoeffsTmp;
-
-                vecIn0 = vld1q(pSamplesTmp);
-                acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
-
-                vecIn0 = vld1q(&pSamplesTmp[1]);
-                acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs);
-
-                pSamplesTmp += 4;
-                pCoeffsTmp += 4;
+                /*
+                 * load 4 coefs
+                 */
+
+                /* acc =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0] */
+                acc0 += ((q63_t) *pSamplesTmp * *pCoeffsTmp) >> 8;
+                acc1 += ((q63_t) pSamplesTmp[1] * *pCoeffsTmp) >> 8;
+                acc2 += ((q63_t) pSamplesTmp[2] * *pCoeffsTmp) >> 8;
+                acc3 += ((q63_t) pSamplesTmp[3] * *pCoeffsTmp) >> 8;
+
+    
+                pSamplesTmp += 1;
+                pCoeffsTmp += 1;
+                /*
+                 * Decrement the taps block loop counter
+                 */
                 i--;
             }
-
+    
+            /* .54-> .31 conversion and store accumulators */
             acc0 = asrl(acc0, 23);
             acc1 = asrl(acc1, 23);
-
+            acc2 = asrl(acc2, 23);
+            acc3 = asrl(acc3, 23);
+    
             *pOutput++ = (q31_t) acc0;
             *pOutput++ = (q31_t) acc1;
-        }
-        break;
-
-    case 1:
-        {
-            const q31_t    *pCoeffsTmp = pCoeffs;
-            const q31_t    *pSamplesTmp = pSamples;
-
-            acc0 = 0LL;
+            *pOutput++ = (q31_t) acc2;
+            *pOutput++ = (q31_t) acc3;
+    
+            pSamples += 4;
 
+            
             /*
-             * Save 4 input samples in the history buffer
+             * Decrement the sample block loop counter
              */
-            vst1q(pStateCur, vld1q(pTempSrc));
-            pStateCur += 4;
-            pTempSrc += 4;
-
-            uint32_t       i = tapsBlkCnt;
-            while (i > 0U)
+            blkCnt--;
+        }
+    
+        uint32_t  residual = blockSize & 3;
+        switch (residual)
+        {
+        case 3:
             {
-                vecCoeffs = *(q31x4_t *) pCoeffsTmp;
-
-                vecIn0 = vld1q(pSamplesTmp);
-                acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
-
-                pSamplesTmp += 4;
-                pCoeffsTmp += 4;
-                i--;
+                const q31_t    *pCoeffsTmp = pCoeffs;
+                const q31_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+                acc1 = 0LL;
+                acc2 = 0LL;
+    
+                /*
+                 * Save 4 input samples in the history buffer
+                 */
+              
+                *(q31x4_t *) pStateCur = *(q31x4_t *) pTempSrc;
+                pStateCur += 4;
+                pTempSrc += 4;
+    
+                tapsBlkCnt = numTaps  / 4;
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    vecCoeffs = *(q31x4_t *) pCoeffsTmp;
+
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[1]);
+                    acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[2]);
+                    acc2 = vrmlaldavhaq(acc2, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 4;
+                    pCoeffsTmp += 4;
+                    i--;
+                }
+
+                tapsBlkCnt = (numTaps ) & 3;
+                
+                i = tapsBlkCnt ;
+                while (i > 0U)
+                {
+                   
+                    /* acc =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0] */
+                    acc0 += ((q63_t) *pSamplesTmp * *pCoeffsTmp) >> 8;
+                    acc1 += ((q63_t) pSamplesTmp[1] * *pCoeffsTmp) >> 8;
+                    acc2 += ((q63_t) pSamplesTmp[2] * *pCoeffsTmp) >> 8;
+    
+                    pSamplesTmp += 1;
+                    pCoeffsTmp += 1;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+    
+                acc0 = asrl(acc0, 23);
+                acc1 = asrl(acc1, 23);
+                acc2 = asrl(acc2, 23);
+    
+                *pOutput++ = (q31_t) acc0;
+                *pOutput++ = (q31_t) acc1;
+                *pOutput++ = (q31_t) acc2;
             }
-
-            acc0 = asrl(acc0, 23);
-
-            *pOutput++ = (q31_t) acc0;
+            break;
+    
+        case 2:
+            {
+                const q31_t    *pCoeffsTmp = pCoeffs;
+                const q31_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+                acc1 = 0LL;
+    
+                /*
+                 * Save 4 input samples in the history buffer
+                 */
+                vst1q(pStateCur, vld1q(pTempSrc));
+                pStateCur += 4;
+                pTempSrc += 4;
+    
+                tapsBlkCnt = (numTaps ) / 4;
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    vecCoeffs = *(q31x4_t *) pCoeffsTmp;
+    
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
+    
+                    vecIn0 = vld1q(&pSamplesTmp[1]);
+                    acc1 = vrmlaldavhaq(acc1, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 4;
+                    pCoeffsTmp += 4;
+                    i--;
+                }
+
+                tapsBlkCnt = (numTaps ) & 3;
+                i = tapsBlkCnt ;
+                while (i > 0U)
+                {
+                   
+
+                    /* acc =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0] */
+                    acc0 += ((q63_t) *pSamplesTmp * *pCoeffsTmp) >> 8;
+                    acc1 += ((q63_t) pSamplesTmp[1] * *pCoeffsTmp) >> 8;
+    
+                    pSamplesTmp += 1;
+                    pCoeffsTmp += 1;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+                acc0 = asrl(acc0, 23);
+                acc1 = asrl(acc1, 23);
+    
+                *pOutput++ = (q31_t) acc0;
+                *pOutput++ = (q31_t) acc1;
+            }
+            break;
+    
+        case 1:
+            {
+                const q31_t    *pCoeffsTmp = pCoeffs;
+                const q31_t    *pSamplesTmp = pSamples;
+    
+                acc0 = 0LL;
+    
+                /*
+                 * Save 4 input samples in the history buffer
+                 */
+                vst1q(pStateCur, vld1q(pTempSrc));
+                pStateCur += 4;
+                pTempSrc += 4;
+    
+                tapsBlkCnt = (numTaps ) / 4;
+                uint32_t       i = tapsBlkCnt;
+                while (i > 0U)
+                {
+                    vecCoeffs = *(q31x4_t *) pCoeffsTmp;
+    
+                    vecIn0 = vld1q(pSamplesTmp);
+                    acc0 = vrmlaldavhaq(acc0, vecIn0, vecCoeffs);
+    
+                    pSamplesTmp += 4;
+                    pCoeffsTmp += 4;
+                    i--;
+                }
+
+                tapsBlkCnt = (numTaps ) & 3;
+                i = tapsBlkCnt ;
+                while (i > 0U)
+                {
+                   
+
+                    /* acc =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0] */
+                    acc0 += ((q63_t) *pSamplesTmp * *pCoeffsTmp) >> 8;
+    
+                    pSamplesTmp += 1;
+                    pCoeffsTmp += 1;
+                    /*
+                     * Decrement the taps block loop counter
+                     */
+                    i--;
+                }
+    
+                acc0 = asrl(acc0, 23);
+    
+                *pOutput++ = (q31_t) acc0;
+            }
+            break;
+        }
+    }
+    else
+    {
+         
+                q31_t *pStateCurnt;                            /* Points to the current sample of the state */
+                q31_t *px;                                     /* Temporary pointer for state buffer */
+          const q31_t *pb;                                     /* Temporary pointer for coefficient buffer */
+                q63_t acc0;                                    /* Accumulator */
+                uint32_t i, blkCnt;                    /* Loop counters */
+          pStateCurnt = &(S->pState[(numTaps - 1U)]);
+          blkCnt = blockSize;
+        
+          while (blkCnt > 0U)
+          {
+            /* Copy one sample at a time into state buffer */
+            *pStateCurnt++ = *pSrc++;
+        
+            /* Set the accumulator to zero */
+            acc0 = 0;
+        
+            /* Initialize state pointer */
+            px = pState;
+        
+            /* Initialize Coefficient pointer */
+            pb = pCoeffs;
+        
+            i = numTaps;
+        
+            /* Perform the multiply-accumulates */
+            do
+            {
+              /* acc =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0] */
+              acc0 += (q63_t) *px++ * *pb++;
+        
+              i--;
+            } while (i > 0U);
+        
+            /* Result is in 2.62 format. Convert to 1.31 and store in destination buffer. */
+            *pDst++ = (q31_t) (acc0 >> 31U);
+        
+            /* Advance state pointer by 1 for the next sample */
+            pState = pState + 1U;
+        
+            /* Decrement loop counter */
+            blkCnt--;
         }
-        break;
     }
 
     /*
      * Copy the samples back into the history buffer start
      */
-    pTempSrc = &pState[blockSize];
-    pTempDest = pState;
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
 
     blkCnt = numTaps >> 2;
     while (blkCnt > 0U)

Source/FilteringFunctions/arm_fir_q7.c

@@ -54,6 +54,433 @@
                    Finally, the result is truncated to 1.7 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+void arm_fir_q7_1_16_mve(const arm_fir_instance_q7 * S, const q7_t * pSrc, q7_t * pDst, uint32_t blockSize)
+{
+    q7_t     *pState = S->pState;   /* State pointer */
+    const q7_t     *pCoeffs = S->pCoeffs; /* Coefficient pointer */
+    q7_t     *pStateCur;        /* Points to the current sample of the state */
+    const q7_t     *pSamples;         /* Temporary pointer to the sample buffer */
+    q7_t     *pOutput;          /* Temporary pointer to the output buffer */
+    const q7_t     *pTempSrc;         /* Temporary pointer to the source data */
+    q7_t     *pTempDest;        /* Temporary pointer to the destination buffer */
+    uint32_t  numTaps = S->numTaps; /* Number of filter coefficients in the filter */
+    uint32_t  blkCnt;
+    q7x16_t  vecIn0;
+    q31_t     acc0, acc1, acc2, acc3;
+    q7x16_t  vecCoeffs;
+
+    /*
+     * pState points to state array which contains previous frame (numTaps - 1) samples
+     * pStateCur points to the location where the new input data should be written
+     */
+    pStateCur   = &(pState[(numTaps - 1u)]);
+    pSamples    = pState;
+    pTempSrc    = pSrc;
+    pOutput     = pDst;
+    blkCnt      = blockSize >> 2;
+
+    /*
+     * load 16 coefs
+     */
+    vecCoeffs = *(q7x16_t *) pCoeffs;
+
+    while (blkCnt > 0U)
+    {
+        /*
+         * Save 16 input samples in the history buffer
+         */
+        vst1q(pStateCur, vld1q(pTempSrc));
+        pStateCur += 16;
+        pTempSrc += 16;
+
+        vecIn0 = vld1q(pSamples);
+        acc0 = vmladavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamples[1]);;
+        acc1 = vmladavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamples[2]);;
+        acc2 = vmladavq(vecIn0, vecCoeffs);
+
+        vecIn0 = vld1q(&pSamples[3]);
+        acc3 = vmladavq(vecIn0, vecCoeffs);
+
+        /*
+         * Store the 1.7 format filter output in destination buffer
+         */
+        *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+        *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+        *pOutput++ = (q7_t) __SSAT((acc2 >> 7U), 8);
+        *pOutput++ = (q7_t) __SSAT((acc3 >> 7U), 8);
+
+        pSamples += 4;
+        /*
+         * Decrement the sample block loop counter
+         */
+        blkCnt--;
+    }
+
+    uint32_t  residual = blockSize & 3;
+    switch (residual)
+    {
+    case 3:
+        {
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 16;
+            pTempSrc += 16;
+
+            vecIn0 = vld1q(pSamples);
+            acc0 = vmladavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamples[1]);
+            acc1 = vmladavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamples[2]);
+            acc2 = vmladavq(vecIn0, vecCoeffs);
+
+            *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+            *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+            *pOutput++ = (q7_t) __SSAT((acc2 >> 7U), 8);
+        }
+        break;
+
+    case 2:
+        {
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 16;
+            pTempSrc += 16;
+
+            vecIn0 = vld1q(pSamples);
+            acc0 = vmladavq(vecIn0, vecCoeffs);
+
+            vecIn0 = vld1q(&pSamples[1]);
+            acc1 = vmladavq(vecIn0, vecCoeffs);
+
+            *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+            *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+        }
+        break;
+
+    case 1:
+        {
+            vst1q(pStateCur, vld1q(pTempSrc));
+            pStateCur += 16;
+            pTempSrc += 16;
+
+            vecIn0 = vld1q(pSamples);
+            acc0 = vmladavq(vecIn0, vecCoeffs);
+
+            *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+        }
+        break;
+    }
+
+    /*
+     * Copy the samples back into the history buffer start
+     */
+    pTempSrc = &pState[blockSize];
+    pTempDest = pState;
+
+    blkCnt = numTaps >> 4;
+    while (blkCnt > 0U)
+    {
+        vst1q(pTempDest, vld1q(pTempSrc));
+        pTempSrc += 16;
+        pTempDest += 16;
+        blkCnt--;
+    }
+    blkCnt = numTaps & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vstrbq_p_s8(pTempDest, vld1q(pTempSrc), p0);
+    }
+}
+
+void arm_fir_q7(
+  const arm_fir_instance_q7 * S,
+  const q7_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize)
+{
+    q7_t     *pState = S->pState;   /* State pointer */
+    const q7_t     *pCoeffs = S->pCoeffs; /* Coefficient pointer */
+    q7_t     *pStateCur;        /* Points to the current sample of the state */
+    const q7_t     *pSamples;         /* Temporary pointer to the sample buffer */
+    q7_t     *pOutput;          /* Temporary pointer to the output buffer */
+    const q7_t     *pTempSrc;         /* Temporary pointer to the source data */
+    q7_t     *pTempDest;        /* Temporary pointer to the destination buffer */
+    uint32_t  numTaps = S->numTaps; /* Number of filter coefficients in the filter */
+    uint32_t  blkCnt;
+    q7x16_t  vecIn0;
+    uint32_t  tapsBlkCnt = (numTaps + 15) / 16;
+    q31_t     acc0, acc1, acc2, acc3;
+    q7x16_t  vecCoeffs;
+
+    if (blockSize >= 20)
+    {
+        if (numTaps <= 16)
+        {
+            /*
+             * [1 to 16 taps] specialized routine
+             */
+            arm_fir_q7_1_16_mve(S, pSrc, pDst, blockSize);
+            return;
+        }
+    }
+
+    if (blockSize >= 20)
+    {
+      /*
+       * pState points to state array which contains previous frame (numTaps - 1) samples
+       * pStateCur points to the location where the new input data should be written
+       */
+      pStateCur   = &(pState[(numTaps - 1u)]);
+      pSamples    = pState;
+      pTempSrc    = pSrc;
+      pOutput     = pDst;
+      blkCnt      = blockSize >> 2;
+  
+      /*
+       * outer samples loop
+       */
+      while (blkCnt > 0U)
+      {
+          const q7_t     *pCoeffsTmp = pCoeffs;
+          const q7_t     *pSamplesTmp = pSamples;
+  
+          acc0 = 0;
+          acc1 = 0;
+          acc2 = 0;
+          acc3 = 0;
+          /*
+           * Save 16 input samples in the history buffer
+           */
+          vst1q(pStateCur, vld1q(pTempSrc));
+          pStateCur += 16;
+          pTempSrc += 16;
+  
+          /*
+           * inner coefficients loop
+           */
+          uint32_t       i = tapsBlkCnt;
+          while (i > 0U)
+          {
+              /*
+               * load 16 coefs
+               */
+              vecCoeffs = *(q7x16_t *) pCoeffsTmp;
+  
+              vecIn0 = vld1q(pSamplesTmp);
+              acc0 = vmladavaq(acc0, vecIn0, vecCoeffs);
+  
+              vecIn0 = vld1q(&pSamplesTmp[1]);
+              acc1 = vmladavaq(acc1, vecIn0, vecCoeffs);
+  
+              vecIn0 = vld1q(&pSamplesTmp[2]);
+              acc2 = vmladavaq(acc2, vecIn0, vecCoeffs);
+  
+              vecIn0 = vld1q(&pSamplesTmp[3]);
+              acc3 = vmladavaq(acc3, vecIn0, vecCoeffs);
+  
+              pSamplesTmp += 16;
+              pCoeffsTmp += 16;
+              /*
+               * Decrement the taps block loop counter
+               */
+              i--;
+          }
+          /*
+           * Store the 1.7 format filter output in destination buffer
+           */
+          *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+          *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+          *pOutput++ = (q7_t) __SSAT((acc2 >> 7U), 8);
+          *pOutput++ = (q7_t) __SSAT((acc3 >> 7U), 8);
+  
+          pSamples += 4;
+          /*
+           * Decrement the sample block loop counter
+           */
+          blkCnt--;
+      }
+  
+      uint32_t  residual = blockSize & 3;
+      switch (residual)
+      {
+      case 3:
+          {
+              const q7_t     *pCoeffsTmp = pCoeffs;
+              const q7_t     *pSamplesTmp = pSamples;
+  
+              acc0 = 0;
+              acc1 = 0;
+              acc2 = 0;
+              /*
+               * Save 16 input samples in the history buffer
+               */
+              vst1q(pStateCur, vld1q(pTempSrc));
+              pStateCur += 16;
+              pTempSrc += 16;
+  
+              uint32_t       i = tapsBlkCnt;
+              while (i > 0U)
+              {
+                  vecCoeffs = *(q7x16_t *) pCoeffsTmp;
+  
+                  vecIn0 = vld1q(pSamplesTmp);
+                  acc0 = vmladavaq(acc0, vecIn0, vecCoeffs);
+  
+                  vecIn0 = vld1q(&pSamplesTmp[1]);
+                  acc1 = vmladavaq(acc1, vecIn0, vecCoeffs);
+  
+                  vecIn0 = vld1q(&pSamplesTmp[2]);
+                  acc2 = vmladavaq(acc2, vecIn0, vecCoeffs);
+  
+                  pSamplesTmp += 16;
+                  pCoeffsTmp += 16;
+                  i--;
+              }
+  
+              *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+              *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+              *pOutput++ = (q7_t) __SSAT((acc2 >> 7U), 8);
+          }
+          break;
+  
+      case 2:
+          {
+              const q7_t     *pCoeffsTmp = pCoeffs;
+              const q7_t     *pSamplesTmp = pSamples;
+  
+              acc0 = 0;
+              acc1 = 0;
+              /*
+               * Save 16 input samples in the history buffer
+               */
+              vst1q(pStateCur, vld1q(pTempSrc));
+              pStateCur += 16;
+              pTempSrc += 16;
+  
+              uint32_t       i = tapsBlkCnt;
+              while (i > 0U)
+              {
+                  vecCoeffs = *(q7x16_t *) pCoeffsTmp;
+  
+                  vecIn0 = vld1q(pSamplesTmp);
+                  acc0 = vmladavaq(acc0, vecIn0, vecCoeffs);
+  
+                  vecIn0 = vld1q(&pSamplesTmp[1]);
+                  acc1 = vmladavaq(acc1, vecIn0, vecCoeffs);
+  
+                  pSamplesTmp += 16;
+                  pCoeffsTmp += 16;
+                  i--;
+              }
+  
+              *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+              *pOutput++ = (q7_t) __SSAT((acc1 >> 7U), 8);
+          }
+          break;
+  
+      case 1:
+          {
+              const q7_t     *pCoeffsTmp = pCoeffs;
+              const q7_t     *pSamplesTmp = pSamples;
+  
+              acc0 = 0;
+              /*
+               * Save 16 input samples in the history buffer
+               */
+              vst1q(pStateCur, vld1q(pTempSrc));
+              pStateCur += 16;
+              pTempSrc += 16;
+  
+              uint32_t       i = tapsBlkCnt;
+              while (i > 0U)
+              {
+                  vecCoeffs = *(q7x16_t *) pCoeffsTmp;
+  
+                  vecIn0 = vld1q(pSamplesTmp);
+                  acc0 = vmladavaq(acc0, vecIn0, vecCoeffs);
+  
+                  pSamplesTmp += 16;
+                  pCoeffsTmp += 16;
+                  i--;
+              }
+              *pOutput++ = (q7_t) __SSAT((acc0 >> 7U), 8);
+          }
+          break;
+      }
+    }
+    else
+    {
+        q7_t *pStateCurnt;                            /* Points to the current sample of the state */
+            q7_t *px;                                     /* Temporary pointer for state buffer */
+      const q7_t *pb;                                     /* Temporary pointer for coefficient buffer */
+            q31_t acc0;                                    /* Accumulator */
+            uint32_t  i,blkCnt;                    /* Loop counters */
+      pStateCurnt = &(S->pState[(numTaps - 1U)]);
+      blkCnt = blockSize;
+
+         while (blkCnt > 0U)
+           {
+             /* Copy one sample at a time into state buffer */
+             *pStateCurnt++ = *pSrc++;
+         
+             /* Set the accumulator to zero */
+             acc0 = 0;
+         
+             /* Initialize state pointer */
+             px = pState;
+         
+             /* Initialize Coefficient pointer */
+             pb = pCoeffs;
+         
+             i = numTaps;
+         
+             /* Perform the multiply-accumulates */
+             while (i > 0U)
+             {
+               acc0 += (q15_t) * (px++) * (*(pb++));
+               i--;
+             } 
+         
+             /* The result is in 2.14 format. Convert to 1.7
+                Then store the output in the destination buffer. */
+             *pDst++ = __SSAT((acc0 >> 7U), 8);
+         
+             /* Advance state pointer by 1 for the next sample */
+             pState = pState + 1U;
+         
+             /* Decrement loop counter */
+             blkCnt--;
+           }
+    }
+    /*
+     * Copy the samples back into the history buffer start
+     */
+    pTempSrc = &S->pState[blockSize];
+    pTempDest = S->pState;
+
+    blkCnt = numTaps >> 4;
+    while (blkCnt > 0U)
+    {
+        vst1q(pTempDest, vld1q(pTempSrc));
+        pTempSrc += 16;
+        pTempDest += 16;
+        blkCnt--;
+    }
+    blkCnt = numTaps & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vstrbq_p_s8(pTempDest, vld1q(pTempSrc), p0);
+    }
+}
+#else
 void arm_fir_q7(
   const arm_fir_instance_q7 * S,
   const q7_t * pSrc,
@@ -317,6 +744,7 @@ void arm_fir_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of FIR group

Testing/FrameworkInclude/Error.h

@@ -170,7 +170,7 @@ void assert_equal(unsigned long nb,AnyPattern<T> &pa, AnyPattern<T> &pb)
        }
        catch(Error &err)
        {          
-          sprintf(id," (id=%lu)",i);
+          sprintf(id," (nb=%lu)",i+1);
           strcat(err.details,id);
           throw(err);
        }
@@ -226,7 +226,7 @@ void assert_near_equal(unsigned long nb,AnyPattern<T> &pa, AnyPattern<T> &pb, T
        }
        catch(Error &err)
        {          
-          sprintf(id," (id=%lu)",i);
+          sprintf(id," (nb=%lu)",i+1);
           strcat(err.details,id);
           throw(err);
        }

Testing/FrameworkSource/Error.cpp

@@ -51,7 +51,7 @@ void assert_near_equal(unsigned long nb,double pa, double pb, double threshold)
     if (fabs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %g > %g",fabs(pa - pb) , threshold);
+         sprintf(details,"diff %g > %g (%g,%g)",fabs(pa - pb) , threshold,pa,pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -62,7 +62,7 @@ void assert_near_equal(unsigned long nb,float32_t pa, float32_t pb, float32_t th
     if (fabs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %g > %g",fabs(pa - pb) , threshold);
+         sprintf(details,"diff %g > %g (%g,%g)",fabs(pa - pb) , threshold, pa, pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -74,7 +74,7 @@ void assert_near_equal(unsigned long nb,q63_t pa, q63_t pb, q63_t threshold)
     if (abs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %lld > %lld",abs(pa - pb) , threshold);
+         sprintf(details,"diff %lld > %lld (%016llX,%016llX)",abs(pa - pb) , threshold,pa,pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -85,7 +85,7 @@ void assert_near_equal(unsigned long nb,q31_t pa, q31_t pb, q31_t threshold)
     if (abs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %d > %d",abs(pa - pb) , threshold);
+         sprintf(details,"diff %d > %d (%08X,%08X)",abs(pa - pb) , threshold,pa,pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -96,7 +96,7 @@ void assert_near_equal(unsigned long nb,q15_t pa, q15_t pb, q15_t threshold)
     if (abs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %d > %d",abs(pa - pb) , threshold);
+         sprintf(details,"diff %d > %d (%04X,%04X)",abs(pa - pb) , threshold,pa,pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -107,7 +107,7 @@ void assert_near_equal(unsigned long nb,q7_t pa, q7_t pb, q7_t threshold)
     if (abs(pa - pb) > threshold)
     {
          char details[200];
-         sprintf(details,"diff %d > %d",abs(pa - pb) , threshold);
+         sprintf(details,"diff %d > %d (%02X,%02X)",abs(pa - pb) , threshold,pa,pb);
          throw (Error(EQUAL_ERROR,nb,details));
     }
 };
@@ -186,7 +186,7 @@ void assert_relative_error(unsigned long nb,AnyPattern<float32_t> &pa, AnyPatter
        }
        catch(Error &err)
        {          
-          sprintf(id," (id=%lu)",i);
+          sprintf(id," (nb=%lu)",i+1);
           strcat(err.details,id);
           throw(err);
        }
@@ -228,7 +228,7 @@ void assert_close_error(unsigned long nb,AnyPattern<float64_t> &pref, AnyPattern
        }
        catch(Error &err)
        {          
-          sprintf(id," (id=%lu)",i);
+          sprintf(id," (nb=%lu)",i+1);
           strcat(err.details,id);
           throw(err);
        }
@@ -271,7 +271,7 @@ void assert_close_error(unsigned long nb,AnyPattern<float32_t> &pref, AnyPattern
        }
        catch(Error &err)
        {          
-          sprintf(id," (id=%lu)",i);
+          sprintf(id," (nb=%lu)",i+1);
           strcat(err.details,id);
           throw(err);
        }

Testing/PatternGeneration/FIR.py

@@ -55,13 +55,13 @@ def writeTests(config,format):
     defs=[] 
 
     if format == 0 or format == 31:
-       blk = [1, 2, 3, 8, 11, 16, 23]
+       blk = [1, 2, 3, 8, 9,10,11, 16, 23]
        taps = [1, 2, 3, 4, 5, 6, 7, 8, 11, 16, 23, 25]
     elif format == 15:
-       blk = [1, 2, 3, 8, 11]
-       taps = [1, 2, 3, 4, 5, 6, 7, 8, 11, 25]
+       blk = [1, 2, 3, 12,13,14,15]
+       taps = [2, 3, 4, 5, 6, 7, 8, 11, 25]
     elif format == 7:
-       blk = [1, 2, 3, 8, 11]
+       blk = [1, 2, 3 ,20,21,22,23]
        taps = [1, 2, 3, 4, 5, 6, 7, 8, 11, 25]
 
     configs = cartesian(blk,taps)

Testing/Patterns/DSP/Filtering/FIR/FIRF32/Coefs1_f32.txt

@@ -1,130 +1,130 @@
 W
 64
-// -0.488655
-0xbefa30ee
-// -0.305729
-0xbe9c888b
-// 0.543618
-0x3f0b2a93
-// -0.077362
-0xbd9e6fd6
-// 0.023812
-0x3cc311aa
-// -0.297257
-0xbe983207
+// 0.708499
+0x3f356036
+// -0.395436
+0xbeca76a5
+// -0.243349
+0xbe793093
+// -0.119364
+0xbdf474f4
+// 0.868952
+0x3f5e73a3
+// 0.451955
+0x3ee7669b
+// 0.278130
+0x3e8e670b
+// -0.086488
+0xbdb120de
+// 0.238882
+0x3e749d67
+// 0.051672
+0x3d53a62c
 // -1.000000
 0xbf800000
-// -0.021071
-0xbcac9c73
-// 0.895448
-0x3f653c12
-// 0.723191
-0x3f39230e
-// 0.507527
-0x3f01ed4f
-// -0.293503
-0xbe964609
-// -0.026346
-0xbcd7d388
-// 0.022038
-0x3cb48960
-// -0.645802
-0xbf255341
-// -0.346309
-0xbeb14f7a
-// 0.258503
-0x3e845a71
-// -0.307125
-0xbe9d3f7e
-// 0.096340
-0x3dc54dc7
-// 0.256911
-0x3e8389dd
-// -0.063551
-0xbd82272d
-// 0.555975
-0x3f0e5461
-// -0.412917
-0xbed369d0
-// -0.045198
-0xbd3921fd
-// 0.449100
-0x3ee5f064
-// 0.291735
-0x3e955e51
-// -0.676432
-0xbf2d2aa8
-// 0.303655
-0x3e9b78b0
-// -0.253624
-0xbe81db0a
-// 0.257274
-0x3e83b96b
-// -0.059101
-0xbd7213dd
-// -0.518344
-0xbf04b235
-// 0.195128
-0x3e47cfc1
-// -0.381687
-0xbec36c7d
-// -0.024760
-0xbccad616
-// -0.569513
-0xbf11cba3
-// 0.204694
-0x3e519b40
-// -0.516617
-0xbf044106
-// -0.393688
-0xbec99176
-// 0.281210
-0x3e8ffabf
-// 0.016638
-0x3c884bd8
-// 0.050582
-0x3d4f2eee
-// 0.114955
-0x3deb6da1
-// 0.058042
-0x3d6dbdbd
-// -0.411764
-0xbed2d2bb
-// -0.291694
-0xbe9558f2
-// 0.271195
-0x3e8ada05
-// 0.073311
-0x3d962403
-// -0.654886
-0xbf27a69f
-// -0.673480
-0xbf2c6934
-// -0.148986
-0xbe188fe5
-// -0.157290
-0xbe2110a5
-// -0.446104
-0xbee467af
-// -0.202074
-0xbe4eec9c
-// -0.000992
-0xba81fa42
-// -0.132536
-0xbe07b79f
-// -0.581263
-0xbf14cda9
-// 0.152356
-0x3e1c0350
-// -0.246155
-0xbe7c1002
-// -0.634788
-0xbf228173
-// 0.986091
-0x3f7c7071
-// -0.530790
-0xbf07e1da
-// 0.439830
-0x3ee1316d
-// -0.217365
-0xbe5e9505
+// 0.025681
+0x3cd26077
+// 0.091561
+0x3dbb844a
+// 0.822870
+0x3f52a799
+// 0.610408
+0x3f1c43bb
+// 0.004184
+0x3b89198c
+// -0.080053
+0xbda3f2a5
+// 0.162940
+0x3e26d99d
+// 0.152277
+0x3e1bee7c
+// -0.603645
+0xbf1a8883
+// -0.756232
+0xbf41986a
+// 0.112594
+0x3de69788
+// -0.429175
+0xbedbbcd0
+// -0.536454
+0xbf09550d
+// -0.197814
+0xbe4a8fdf
+// 0.855537
+0x3f5b047c
+// -0.461545
+0xbeec4fa5
+// -0.303635
+0xbe9b7616
+// -0.359261
+0xbeb7f109
+// -0.144109
+0xbe139151
+// 0.243138
+0x3e78f926
+// -0.067385
+0xbd8a013f
+// -0.270352
+0xbe8a6b87
+// -0.354832
+0xbeb5ac8f
+// 0.183437
+0x3e3bd6e5
+// -0.338980
+0xbead8eb9
+// -0.059109
+0xbd721c3d
+// 0.238131
+0x3e73d88d
+// -0.054923
+0xbd60f6d1
+// 0.982719
+0x3f7b937c
+// 0.398771
+0x3ecc2bc2
+// 0.219364
+0x3e60a0e7
+// -0.317896
+0xbea2c334
+// -0.033846
+0xbd0aa26f
+// -0.401330
+0xbecd7b25
+// 0.115229
+0x3debfd72
+// 0.430248
+0x3edc497e
+// 0.305590
+0x3e9c7655
+// -0.044320
+0xbd358966
+// 0.310741
+0x3e9f1968
+// 0.625900
+0x3f203aff
+// 0.000622
+0x3a22f4c4
+// -0.021713
+0xbcb1e010
+// 0.173372
+0x3e318850
+// -0.820373
+0xbf5203fc
+// -0.334060
+0xbeab09e5
+// -0.376804
+0xbec0ec6d
+// 0.267524
+0x3e88f8da
+// 0.565023
+0x3f10a55e
+// 0.775019
+0x3f4667a7
+// -0.090432
+0xbdb93490
+// 0.274172
+0x3e8c6040
+// 0.098676
+0x3dca1683
+// -0.453624
+0xbee8415f

Testing/Patterns/DSP/Filtering/FIR/FIRF32/FirCoefs1_f32.txt

@@ -1,5 +1,449 @@
 W
-777
+999
+// 0.333333
+0x3eaaaaab
+// 0.500000
+0x3f000000
+// 0.250000
+0x3e800000
+// 0.600000
+0x3f19999a
+// 0.400000
+0x3ecccccd
+// 0.200000
+0x3e4ccccd
+// 0.666667
+0x3f2aaaab
+// 0.500000
+0x3f000000
+// 0.333333
+0x3eaaaaab
+// 0.166667
+0x3e2aaaab
+// 0.714286
+0x3f36db6e
+// 0.571429
+0x3f124925
+// 0.428571
+0x3edb6db7
+// 0.285714
+0x3e924925
+// 0.142857
+0x3e124925
+// 0.750000
+0x3f400000
+// 0.625000
+0x3f200000
+// 0.500000
+0x3f000000
+// 0.375000
+0x3ec00000
+// 0.250000
+0x3e800000
+// 0.125000
+0x3e000000
+// 0.777778
+0x3f471c72
+// 0.666667
+0x3f2aaaab
+// 0.555556
+0x3f0e38e4
+// 0.444444
+0x3ee38e39
+// 0.333333
+0x3eaaaaab
+// 0.222222
+0x3e638e39
+// 0.111111
+0x3de38e39
+// 0.800000
+0x3f4ccccd
+// 0.700000
+0x3f333333
+// 0.600000
+0x3f19999a
+// 0.500000
+0x3f000000
+// 0.400000
+0x3ecccccd
+// 0.300000
+0x3e99999a
+// 0.200000
+0x3e4ccccd
+// 0.100000
+0x3dcccccd
+// 0.846154
+0x3f589d8a
+// 0.769231
+0x3f44ec4f
+// 0.692308
+0x3f313b14
+// 0.615385
+0x3f1d89d9
+// 0.538462
+0x3f09d89e
+// 0.461538
+0x3eec4ec5
+// 0.384615
+0x3ec4ec4f
+// 0.307692
+0x3e9d89d9
+// 0.230769
+0x3e6c4ec5
+// 0.153846
+0x3e1d89d9
+// 0.076923
+0x3d9d89d9
+// 0.888889
+0x3f638e39
+// 0.833333
+0x3f555555
+// 0.777778
+0x3f471c72
+// 0.722222
+0x3f38e38e
+// 0.666667
+0x3f2aaaab
+// 0.611111
+0x3f1c71c7
+// 0.555556
+0x3f0e38e4
+// 0.500000
+0x3f000000
+// 0.444444
+0x3ee38e39
+// 0.388889
+0x3ec71c72
+// 0.333333
+0x3eaaaaab
+// 0.277778
+0x3e8e38e4
+// 0.222222
+0x3e638e39
+// 0.166667
+0x3e2aaaab
+// 0.111111
+0x3de38e39
+// 0.055556
+0x3d638e39
+// 0.920000
+0x3f6b851f
+// 0.880000
+0x3f6147ae
+// 0.840000
+0x3f570a3d
+// 0.800000
+0x3f4ccccd
+// 0.760000
+0x3f428f5c
+// 0.720000
+0x3f3851ec
+// 0.680000
+0x3f2e147b
+// 0.640000
+0x3f23d70a
+// 0.600000
+0x3f19999a
+// 0.560000
+0x3f0f5c29
+// 0.520000
+0x3f051eb8
+// 0.480000
+0x3ef5c28f
+// 0.440000
+0x3ee147ae
+// 0.400000
+0x3ecccccd
+// 0.360000
+0x3eb851ec
+// 0.320000
+0x3ea3d70a
+// 0.280000
+0x3e8f5c29
+// 0.240000
+0x3e75c28f
+// 0.200000
+0x3e4ccccd
+// 0.160000
+0x3e23d70a
+// 0.120000
+0x3df5c28f
+// 0.080000
+0x3da3d70a
+// 0.040000
+0x3d23d70a
+// 0.925926
+0x3f6d097b
+// 0.888889
+0x3f638e39
+// 0.851852
+0x3f5a12f7
+// 0.814815
+0x3f5097b4
+// 0.777778
+0x3f471c72
+// 0.740741
+0x3f3da12f
+// 0.703704
+0x3f3425ed
+// 0.666667
+0x3f2aaaab
+// 0.629630
+0x3f212f68
+// 0.592593
+0x3f17b426
+// 0.555556
+0x3f0e38e4
+// 0.518519
+0x3f04bda1
+// 0.481481
+0x3ef684be
+// 0.444444
+0x3ee38e39
+// 0.407407
+0x3ed097b4
+// 0.370370
+0x3ebda12f
+// 0.333333
+0x3eaaaaab
+// 0.296296
+0x3e97b426
+// 0.259259
+0x3e84bda1
+// 0.222222
+0x3e638e39
+// 0.185185
+0x3e3da12f
+// 0.148148
+0x3e17b426
+// 0.111111
+0x3de38e39
+// 0.074074
+0x3d97b426
+// 0.037037
+0x3d17b426
+// 0.333333
+0x3eaaaaab
+// 0.500000
+0x3f000000
+// 0.250000
+0x3e800000
+// 0.600000
+0x3f19999a
+// 0.400000
+0x3ecccccd
+// 0.200000
+0x3e4ccccd
+// 0.666667
+0x3f2aaaab
+// 0.500000
+0x3f000000
+// 0.333333
+0x3eaaaaab
+// 0.166667
+0x3e2aaaab
+// 0.714286
+0x3f36db6e
+// 0.571429
+0x3f124925
+// 0.428571
+0x3edb6db7
+// 0.285714
+0x3e924925
+// 0.142857
+0x3e124925
+// 0.750000
+0x3f400000
+// 0.625000
+0x3f200000
+// 0.500000
+0x3f000000
+// 0.375000
+0x3ec00000
+// 0.250000
+0x3e800000
+// 0.125000
+0x3e000000
+// 0.777778
+0x3f471c72
+// 0.666667
+0x3f2aaaab
+// 0.555556
+0x3f0e38e4
+// 0.444444
+0x3ee38e39
+// 0.333333
+0x3eaaaaab
+// 0.222222
+0x3e638e39
+// 0.111111
+0x3de38e39
+// 0.800000
+0x3f4ccccd
+// 0.700000
+0x3f333333
+// 0.600000
+0x3f19999a
+// 0.500000
+0x3f000000
+// 0.400000
+0x3ecccccd
+// 0.300000
+0x3e99999a
+// 0.200000
+0x3e4ccccd
+// 0.100000
+0x3dcccccd
+// 0.846154
+0x3f589d8a
+// 0.769231
+0x3f44ec4f
+// 0.692308
+0x3f313b14
+// 0.615385
+0x3f1d89d9
+// 0.538462
+0x3f09d89e
+// 0.461538
+0x3eec4ec5
+// 0.384615
+0x3ec4ec4f
+// 0.307692
+0x3e9d89d9
+// 0.230769
+0x3e6c4ec5
+// 0.153846
+0x3e1d89d9
+// 0.076923
+0x3d9d89d9
+// 0.888889
+0x3f638e39
+// 0.833333
+0x3f555555
+// 0.777778
+0x3f471c72
+// 0.722222
+0x3f38e38e
+// 0.666667
+0x3f2aaaab
+// 0.611111
+0x3f1c71c7
+// 0.555556
+0x3f0e38e4
+// 0.500000
+0x3f000000
+// 0.444444
+0x3ee38e39
+// 0.388889
+0x3ec71c72
+// 0.333333
+0x3eaaaaab
+// 0.277778
+0x3e8e38e4
+// 0.222222
+0x3e638e39
+// 0.166667
+0x3e2aaaab
+// 0.111111
+0x3de38e39
+// 0.055556
+0x3d638e39
+// 0.920000
+0x3f6b851f
+// 0.880000
+0x3f6147ae
+// 0.840000
+0x3f570a3d
+// 0.800000
+0x3f4ccccd
+// 0.760000
+0x3f428f5c
+// 0.720000
+0x3f3851ec
+// 0.680000
+0x3f2e147b
+// 0.640000
+0x3f23d70a
+// 0.600000
+0x3f19999a
+// 0.560000
+0x3f0f5c29
+// 0.520000
+0x3f051eb8
+// 0.480000
+0x3ef5c28f
+// 0.440000
+0x3ee147ae
+// 0.400000
+0x3ecccccd
+// 0.360000
+0x3eb851ec
+// 0.320000
+0x3ea3d70a
+// 0.280000
+0x3e8f5c29
+// 0.240000
+0x3e75c28f
+// 0.200000
+0x3e4ccccd
+// 0.160000
+0x3e23d70a
+// 0.120000
+0x3df5c28f
+// 0.080000
+0x3da3d70a
+// 0.040000
+0x3d23d70a
+// 0.925926
+0x3f6d097b
+// 0.888889
+0x3f638e39
+// 0.851852
+0x3f5a12f7
+// 0.814815
+0x3f5097b4
+// 0.777778
+0x3f471c72
+// 0.740741
+0x3f3da12f
+// 0.703704
+0x3f3425ed
+// 0.666667
+0x3f2aaaab
+// 0.629630
+0x3f212f68
+// 0.592593
+0x3f17b426
+// 0.555556
+0x3f0e38e4
+// 0.518519
+0x3f04bda1
+// 0.481481
+0x3ef684be
+// 0.444444
+0x3ee38e39
+// 0.407407
+0x3ed097b4
+// 0.370370
+0x3ebda12f
+// 0.333333
+0x3eaaaaab
+// 0.296296
+0x3e97b426
+// 0.259259
+0x3e84bda1
+// 0.222222
+0x3e638e39
+// 0.185185
+0x3e3da12f
+// 0.148148
+0x3e17b426
+// 0.111111
+0x3de38e39
+// 0.074074
+0x3d97b426
+// 0.037037
+0x3d17b426
 // 0.333333
 0x3eaaaaab
 // 0.500000

Testing/Patterns/DSP/Filtering/FIR/FIRF32/FirConfigs1_s16.txt

@@ -1,5 +1,5 @@
 H
-168
+216
 // 1
 0x0001
 // 1
@@ -192,6 +192,102 @@ H
 0x0008
 // 25
 0x0019
+// 9
+0x0009
+// 1
+0x0001
+// 9
+0x0009
+// 2
+0x0002
+// 9
+0x0009
+// 3
+0x0003
+// 9
+0x0009
+// 4
+0x0004
+// 9
+0x0009
+// 5
+0x0005
+// 9
+0x0009
+// 6
+0x0006
+// 9
+0x0009
+// 7
+0x0007
+// 9
+0x0009
+// 8
+0x0008
+// 9
+0x0009
+// 11
+0x000B
+// 9
+0x0009
+// 16
+0x0010
+// 9
+0x0009
+// 23
+0x0017
+// 9
+0x0009
+// 25
+0x0019
+// 10
+0x000A
+// 1
+0x0001
+// 10
+0x000A
+// 2
+0x0002
+// 10
+0x000A
+// 3
+0x0003
+// 10
+0x000A
+// 4
+0x0004
+// 10
+0x000A
+// 5
+0x0005
+// 10
+0x000A
+// 6
+0x0006
+// 10
+0x000A
+// 7
+0x0007
+// 10
+0x000A
+// 8
+0x0008
+// 10
+0x000A
+// 11
+0x000B
+// 10
+0x000A
+// 16
+0x0010
+// 10
+0x000A
+// 23
+0x0017
+// 10
+0x000A
+// 25
+0x0019
 // 11
 0x000B
 // 1

Testing/Patterns/DSP/Filtering/FIR/FIRF32/FirInput1_f32.txt

@@ -1,94 +1,94 @@
 W
 46
-// 0.002192
-0x3b0fa41e
-// 0.020534
-0x3ca836db
-// 0.027322
-0x3cdfd1c5
-// 0.026860
-0x3cdc0a6d
-// 0.011444
-0x3c3b8184
-// -0.007563
-0xbbf7d5b4
-// -0.024644
-0xbcc9e276
-// -0.027259
-0xbcdf4f3c
-// -0.021891
-0xbcb355c8
-// 0.001055
-0x3a8a4be1
-// 0.022344
-0x3cb70b24
-// 0.027327
-0x3cdfdbfa
-// 0.023073
-0x3cbd0319
-// 0.009354
-0x3c194258
-// -0.007111
-0xbbe90522
-// -0.019643
-0xbca0ea0c
-// -0.029853
-0xbcf48db0
-// -0.019234
-0xbc9d913c
-// -0.002017
-0xbb042bd5
-// 0.014282
-0x3c69fd5e
-// 0.024597
-0x3cc98034
-// 0.021232
-0x3cadeeeb
-// 0.012919
-0x3c53aac6
-// -0.012221
-0xbc48387f
-// -0.025151
-0xbcce087e
-// -0.028886
-0xbceca157
-// -0.021434
-0xbcaf9740
-// 0.001501
-0x3ac4ca97
-// 0.019082
-0x3c9c50e8
-// 0.025940
-0x3cd47f84
-// 0.027926
-0x3ce4c556
-// 0.009921
-0x3c228b80
-// -0.013082
-0xbc5655e0
-// -0.027423
-0xbce0a5ca
-// -0.033333
-0xbd088889
-// -0.021187
-0xbcad9031
-// -0.004010
-0xbb83666d
-// 0.023101
-0x3cbd3e3d
-// 0.025360
-0x3ccfbeba
-// 0.027450
-0x3ce0df23
-// 0.009591
-0x3c1d224c
-// -0.008435
-0xbc0a32e1
-// -0.023286
-0xbcbec1d8
-// -0.030024
-0xbcf5f51f
-// -0.019220
-0xbc9d7318
-// -0.003244
-0xbb54a0ae
+// -0.002449
+0xbb207c19
+// 0.023878
+0x3cc39c9a
+// 0.032970
+0x3d070c02
+// 0.031721
+0x3d01ed6a
+// 0.011642
+0x3c3ebce3
+// -0.011077
+0xbc357d1c
+// -0.029095
+0xbcee584c
+// -0.031569
+0xbd014eda
+// -0.021035
+0xbcac50dd
+// 0.002164
+0x3b0dd877
+// 0.020192
+0x3ca56991
+// 0.033333
+0x3d088889
+// 0.027670
+0x3ce2ab2b
+// 0.011331
+0x3c39a4c2
+// -0.015426
+0xbc7cbeca
+// -0.032912
+0xbd06ce3a
+// -0.030204
+0xbcf76dc7
+// -0.020730
+0xbca9d104
+// -0.002083
+0xbb088946
+// 0.015068
+0x3c76df13
+// 0.028168
+0x3ce6c012
+// 0.028682
+0x3ceaf632
+// 0.012665
+0x3c4f7fa8
+// -0.012774
+0xbc514b8d
+// -0.031027
+0xbcfe2bb4
+// -0.033321
+0xbd087bea
+// -0.025895
+0xbcd420da
+// -0.001772
+0xbae84bad
+// 0.024264
+0x3cc6c4e5
+// 0.027989
+0x3ce549ac
+// 0.028549
+0x3ce9df3c
+// 0.015150
+0x3c783648
+// -0.009234
+0xbc174ba8
+// -0.029320
+0xbcf02f7d
+// -0.030121
+0xbcf6bf91
+// -0.022157
+0xbcb5820d
+// -0.001819
+0xbaee7a09
+// 0.026664
+0x3cda6f1b
+// 0.030173
+0x3cf72d35
+// 0.029774
+0x3cf3e82d
+// 0.013984
+0x3c651e0d
+// -0.007304
+0xbbef54e7
+// -0.032698
+0xbd05ede5
+// -0.031488
+0xbd00f92e
+// -0.017170
+0xbc8ca800
+// 0.000042
+0x38317ece

Testing/Patterns/DSP/Filtering/FIR/FIRQ15/Coefs1_q15.txt

@@ -1,130 +1,130 @@
 H
 64
-// -0.167122
-0xEA9C
-// 0.041085
-0x0542
+// -0.188446
+0xE7E1
+// -0.224111
+0xE350
+// -0.099404
+0xF347
+// -0.152151
+0xEC86
+// -0.623366
+0xB036
+// -0.124210
+0xF01A
+// -0.621314
+0xB079
+// -0.647639
+0xAD1A
+// -0.068427
+0xF73E
+// -0.222140
+0xE391
+// 0.091323
+0x0BB0
+// 0.035140
+0x047F
+// -0.216105
+0xE457
+// -0.103723
+0xF2B9
 // -1.000000
 0x8000
-// -0.467343
-0xC42E
-// -0.025549
-0xFCBB
-// -0.331005
-0xD5A2
-// 0.059851
-0x07A9
-// 0.040286
-0x0528
-// 0.710366
-0x5AED
-// -0.017774
-0xFDBA
-// -0.014706
-0xFE1E
-// 0.184477
-0x179D
-// 0.641585
-0x521F
-// 0.010706
-0x015F
-// -0.546564
-0xBA0A
-// 0.029256
-0x03BF
-// 0.015539
-0x01FD
-// -0.120463
-0xF095
-// 0.281078
-0x23FA
-// -0.137106
-0xEE73
-// -0.057143
-0xF8B0
-// -0.290425
-0xDAD3
-// 0.103329
-0x0D3A
-// 0.362765
-0x2E6F
-// -0.646532
-0xAD3E
-// 0.115809
-0x0ED3
-// 0.215445
-0x1B94
-// -0.216234
-0xE452
-// 0.371913
-0x2F9B
-// -0.541059
-0xBABF
-// 0.191476
-0x1882
-// -0.085940
-0xF500
-// -0.488651
-0xC174
-// -0.766034
-0x9DF3
-// 0.471843
-0x3C65
-// 0.234323
-0x1DFE
-// -0.142792
-0xEDB9
-// -0.318739
-0xD734
-// 0.540150
-0x4524
-// 0.210395
-0x1AEE
-// 0.113412
-0x0E84
-// 0.080853
-0x0A59
-// -0.064999
-0xF7AE
-// 0.132397
-0x10F2
-// -0.458349
-0xC555
-// -0.161362
-0xEB58
-// 0.212606
-0x1B37
-// 0.407670
-0x342F
-// 0.241639
-0x1EEE
-// -0.149194
-0xECE7
-// 0.387535
-0x319B
-// -0.159324
+// -0.534845
+0xBB8A
+// 0.555924
+0x4729
+// -0.159319
 0xEB9B
-// -0.317577
-0xD75A
-// -0.405661
-0xCC13
-// -0.224868
-0xE338
-// -0.359911
-0xD1EE
-// 0.039551
-0x0510
-// -0.068337
-0xF741
-// -0.157341
-0xEBDC
-// -0.037047
-0xFB42
-// -0.183824
-0xE878
-// 0.483951
-0x3DF2
-// -0.233759
-0xE214
-// 0.253102
-0x2066
+// -0.801495
+0x9969
+// -0.126852
+0xEFC3
+// 0.078115
+0x0A00
+// -0.281731
+0xDBF0
+// -0.491432
+0xC119
+// -0.265365
+0xDE09
+// -0.252914
+0xDFA1
+// -0.568939
+0xB72D
+// -0.526764
+0xBC93
+// 0.076597
+0x09CE
+// 0.251343
+0x202C
+// -0.263467
+0xDE47
+// 0.663568
+0x54F0
+// 0.198565
+0x196B
+// -0.085356
+0xF513
+// 0.598999
+0x4CAC
+// 0.474950
+0x3CCB
+// -0.385391
+0xCEAB
+// -0.004976
+0xFF5D
+// 0.047177
+0x060A
+// -0.360263
+0xD1E3
+// 0.244122
+0x1F3F
+// 0.365875
+0x2ED5
+// 0.203034
+0x19FD
+// -0.020817
+0xFD56
+// 0.581283
+0x4A67
+// -0.177896
+0xE93B
+// -0.114706
+0xF151
+// -0.134792
+0xEEBF
+// 0.164261
+0x1507
+// -0.591260
+0xB452
+// -0.277445
+0xDC7D
+// -0.012337
+0xFE6C
+// -0.247831
+0xE047
+// -0.511281
+0xBE8E
+// 0.633314
+0x5110
+// 0.345806
+0x2C43
+// -0.029051
+0xFC48
+// -0.254047
+0xDF7B
+// 0.591211
+0x4BAD
+// -0.540015
+0xBAE1
+// 0.252184
+0x2048
+// -0.404365
+0xCC3E
+// -0.562314
+0xB806
+// 0.086987
+0x0B22
+// 0.675517
+0x5677

Testing/Patterns/DSP/Filtering/FIR/FIRQ15/FirCoefs1_q15.txt

@@ -1,9 +1,5 @@
 H
-390
-// 0.000000
-0x0000
-// 0.333333
-0x2AAB
+532
 // 0.500000
 0x4000
 // 0.250000
@@ -156,10 +152,6 @@ H
 0x097B
 // 0.037037
 0x04BE
-// 0.000000
-0x0000
-// 0.333333
-0x2AAB
 // 0.500000
 0x4000
 // 0.250000
@@ -312,10 +304,6 @@ H
 0x097B
 // 0.037037
 0x04BE
-// 0.000000
-0x0000
-// 0.333333
-0x2AAB
 // 0.500000
 0x4000
 // 0.250000
@@ -468,10 +456,158 @@ H
 0x097B
 // 0.037037
 0x04BE
+// 0.500000
+0x4000
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.600000
+0x4CCD
+// 0.400000
+0x3333
+// 0.200000
+0x199A
+// 0.666667
+0x5555
+// 0.500000
+0x4000
+// 0.333333
+0x2AAB
+// 0.166667
+0x1555
+// 0.000000
+0x0000
+// 0.714286
+0x5B6E
+// 0.571429
+0x4925
+// 0.428571
+0x36DB
+// 0.285714
+0x2492
+// 0.142857
+0x1249
+// 0.750000
+0x6000
+// 0.625000
+0x5000
+// 0.500000
+0x4000
+// 0.375000
+0x3000
+// 0.250000
+0x2000
+// 0.125000
+0x1000
+// 0.000000
+0x0000
+// 0.777778
+0x638E
+// 0.666667
+0x5555
+// 0.555556
+0x471C
+// 0.444444
+0x38E4
+// 0.333333
+0x2AAB
+// 0.222222
+0x1C72
+// 0.111111
+0x0E39
+// 0.800000
+0x6666
+// 0.700000
+0x599A
+// 0.600000
+0x4CCD
+// 0.500000
+0x4000
+// 0.400000
+0x3333
+// 0.300000
+0x2666
+// 0.200000
+0x199A
+// 0.100000
+0x0CCD
 // 0.000000
 0x0000
+// 0.846154
+0x6C4F
+// 0.769231
+0x6276
+// 0.692308
+0x589E
+// 0.615385
+0x4EC5
+// 0.538462
+0x44EC
+// 0.461538
+0x3B14
+// 0.384615
+0x313B
+// 0.307692
+0x2762
+// 0.230769
+0x1D8A
+// 0.153846
+0x13B1
+// 0.076923
+0x09D9
+// 0.000000
+0x0000
+// 0.925926
+0x7685
+// 0.888889
+0x71C7
+// 0.851852
+0x6D09
+// 0.814815
+0x684C
+// 0.777778
+0x638E
+// 0.740741
+0x5ED1
+// 0.703704
+0x5A13
+// 0.666667
+0x5555
+// 0.629630
+0x5098
+// 0.592593
+0x4BDA
+// 0.555556
+0x471C
+// 0.518519
+0x425F
+// 0.481481
+0x3DA1
+// 0.444444
+0x38E4
+// 0.407407
+0x3426
+// 0.370370
+0x2F68
 // 0.333333
 0x2AAB
+// 0.296296
+0x25ED
+// 0.259259
+0x212F
+// 0.222222
+0x1C72
+// 0.185185
+0x17B4
+// 0.148148
+0x12F7
+// 0.111111
+0x0E39
+// 0.074074
+0x097B
+// 0.037037
+0x04BE
 // 0.500000
 0x4000
 // 0.250000
@@ -624,10 +760,158 @@ H
 0x097B
 // 0.037037
 0x04BE
+// 0.500000
+0x4000
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.600000
+0x4CCD
+// 0.400000
+0x3333
+// 0.200000
+0x199A
+// 0.666667
+0x5555
+// 0.500000
+0x4000
+// 0.333333
+0x2AAB
+// 0.166667
+0x1555
+// 0.000000
+0x0000
+// 0.714286
+0x5B6E
+// 0.571429
+0x4925
+// 0.428571
+0x36DB
+// 0.285714
+0x2492
+// 0.142857
+0x1249
+// 0.750000
+0x6000
+// 0.625000
+0x5000
+// 0.500000
+0x4000
+// 0.375000
+0x3000
+// 0.250000
+0x2000
+// 0.125000
+0x1000
+// 0.000000
+0x0000
+// 0.777778
+0x638E
+// 0.666667
+0x5555
+// 0.555556
+0x471C
+// 0.444444
+0x38E4
+// 0.333333
+0x2AAB
+// 0.222222
+0x1C72
+// 0.111111
+0x0E39
+// 0.800000
+0x6666
+// 0.700000
+0x599A
+// 0.600000
+0x4CCD
+// 0.500000
+0x4000
+// 0.400000
+0x3333
+// 0.300000
+0x2666
+// 0.200000
+0x199A
+// 0.100000
+0x0CCD
 // 0.000000
 0x0000
+// 0.846154
+0x6C4F
+// 0.769231
+0x6276
+// 0.692308
+0x589E
+// 0.615385
+0x4EC5
+// 0.538462
+0x44EC
+// 0.461538
+0x3B14
+// 0.384615
+0x313B
+// 0.307692
+0x2762
+// 0.230769
+0x1D8A
+// 0.153846
+0x13B1
+// 0.076923
+0x09D9
+// 0.000000
+0x0000
+// 0.925926
+0x7685
+// 0.888889
+0x71C7
+// 0.851852
+0x6D09
+// 0.814815
+0x684C
+// 0.777778
+0x638E
+// 0.740741
+0x5ED1
+// 0.703704
+0x5A13
+// 0.666667
+0x5555
+// 0.629630
+0x5098
+// 0.592593
+0x4BDA
+// 0.555556
+0x471C
+// 0.518519
+0x425F
+// 0.481481
+0x3DA1
+// 0.444444
+0x38E4
+// 0.407407
+0x3426
+// 0.370370
+0x2F68
 // 0.333333
 0x2AAB
+// 0.296296
+0x25ED
+// 0.259259
+0x212F
+// 0.222222
+0x1C72
+// 0.185185
+0x17B4
+// 0.148148
+0x12F7
+// 0.111111
+0x0E39
+// 0.074074
+0x097B
+// 0.037037
+0x04BE
 // 0.500000
 0x4000
 // 0.250000

Testing/Patterns/DSP/Filtering/FIR/FIRQ15/FirConfigs1_s16.txt

@@ -1,9 +1,5 @@
 H
-100
-// 1
-0x0001
-// 2
-0x0002
+126
 // 1
 0x0001
 // 2
@@ -46,10 +42,6 @@ H
 0x0002
 // 2
 0x0002
-// 2
-0x0002
-// 2
-0x0002
 // 4
 0x0004
 // 2
@@ -86,10 +78,6 @@ H
 0x0002
 // 3
 0x0003
-// 2
-0x0002
-// 3
-0x0003
 // 4
 0x0004
 // 3
@@ -120,83 +108,147 @@ H
 0x0003
 // 26
 0x001A
-// 8
-0x0008
+// 12
+0x000C
 // 2
 0x0002
+// 12
+0x000C
+// 4
+0x0004
+// 12
+0x000C
+// 4
+0x0004
+// 12
+0x000C
+// 6
+0x0006
+// 12
+0x000C
+// 6
+0x0006
+// 12
+0x000C
 // 8
 0x0008
-// 2
-0x0002
+// 12
+0x000C
 // 8
 0x0008
+// 12
+0x000C
+// 12
+0x000C
+// 12
+0x000C
+// 26
+0x001A
+// 13
+0x000D
+// 2
+0x0002
+// 13
+0x000D
 // 4
 0x0004
-// 8
-0x0008
+// 13
+0x000D
 // 4
 0x0004
-// 8
-0x0008
+// 13
+0x000D
 // 6
 0x0006
-// 8
-0x0008
+// 13
+0x000D
 // 6
 0x0006
+// 13
+0x000D
 // 8
 0x0008
+// 13
+0x000D
 // 8
 0x0008
+// 13
+0x000D
+// 12
+0x000C
+// 13
+0x000D
+// 26
+0x001A
+// 14
+0x000E
+// 2
+0x0002
+// 14
+0x000E
+// 4
+0x0004
+// 14
+0x000E
+// 4
+0x0004
+// 14
+0x000E
+// 6
+0x0006
+// 14
+0x000E
+// 6
+0x0006
+// 14
+0x000E
 // 8
 0x0008
+// 14
+0x000E
 // 8
 0x0008
-// 8
-0x0008
+// 14
+0x000E
 // 12
 0x000C
-// 8
-0x0008
+// 14
+0x000E
 // 26
 0x001A
-// 11
-0x000B
-// 2
-0x0002
-// 11
-0x000B
+// 15
+0x000F
 // 2
 0x0002
-// 11
-0x000B
+// 15
+0x000F
 // 4
 0x0004
-// 11
-0x000B
+// 15
+0x000F
 // 4
 0x0004
-// 11
-0x000B
+// 15
+0x000F
 // 6
 0x0006
-// 11
-0x000B
+// 15
+0x000F
 // 6
 0x0006
-// 11
-0x000B
+// 15
+0x000F
 // 8
 0x0008
-// 11
-0x000B
+// 15
+0x000F
 // 8
 0x0008
-// 11
-0x000B
+// 15
+0x000F
 // 12
 0x000C
-// 11
-0x000B
+// 15
+0x000F
 // 26
 0x001A

Testing/Patterns/DSP/Filtering/FIR/FIRQ15/FirInput1_q15.txt

@@ -1,94 +1,94 @@
 H
 46
-// -0.001578
-0xFFCC
-// 0.022370
-0x02DD
-// 0.031800
-0x0412
-// 0.029809
-0x03D1
-// 0.009696
-0x013E
-// -0.012180
+// -0.001777
+0xFFC6
+// 0.018100
+0x0251
+// 0.027044
+0x0376
+// 0.021092
+0x02B3
+// 0.010499
+0x0158
+// -0.012605
+0xFE63
+// -0.025281
+0xFCC4
+// -0.028888
+0xFC4D
+// -0.020837
+0xFD55
+// -0.000570
+0xFFED
+// 0.020596
+0x02A3
+// 0.026749
+0x036D
+// 0.025331
+0x033E
+// 0.009976
+0x0147
+// -0.012166
 0xFE71
-// -0.025470
+// -0.028882
+0xFC4E
+// -0.028110
+0xFC67
+// -0.020576
+0xFD5E
+// -0.006227
+0xFF34
+// 0.022204
+0x02D8
+// 0.025394
+0x0340
+// 0.026418
+0x0362
+// 0.009993
+0x0147
+// -0.009062
+0xFED7
+// -0.025479
 0xFCBD
+// -0.031450
+0xFBF9
+// -0.016497
+0xFDE3
+// 0.001748
+0x0039
+// 0.019006
+0x026F
+// 0.026238
+0x035C
+// 0.026295
+0x035E
+// 0.012501
+0x019A
+// -0.008537
+0xFEE8
+// -0.026191
+0xFCA6
+// -0.028933
+0xFC4C
+// -0.017844
+0xFDB7
+// -0.002065
+0xFFBC
+// 0.016222
+0x0214
+// 0.026871
+0x0371
+// 0.023087
+0x02F5
+// 0.011919
+0x0187
+// -0.013482
+0xFE46
+// -0.028857
+0xFC4E
 // -0.033333
 0xFBBC
-// -0.017364
-0xFDC7
-// -0.000134
-0xFFFC
-// 0.020261
-0x0298
-// 0.032453
-0x0427
-// 0.026206
-0x035B
-// 0.007367
-0x00F1
-// -0.012267
-0xFE6E
-// -0.027247
-0xFC83
-// -0.028953
-0xFC4B
-// -0.022472
-0xFD20
-// 0.001606
-0x0035
-// 0.023970
-0x0311
-// 0.031669
-0x040E
-// 0.028359
-0x03A1
-// 0.011205
-0x016F
-// -0.011007
-0xFE97
-// -0.030164
-0xFC24
-// -0.029474
-0xFC3A
-// -0.022559
-0xFD1D
-// 0.003345
-0x006E
-// 0.019856
-0x028B
-// 0.028855
-0x03B2
-// 0.024937
-0x0331
-// 0.009772
-0x0140
-// -0.008130
-0xFEF6
-// -0.027173
-0xFC86
-// -0.030286
-0xFC20
-// -0.024042
-0xFCEC
-// 0.001499
-0x0031
-// 0.022588
-0x02E4
-// 0.030631
-0x03EC
-// 0.032070
-0x041B
-// 0.011184
-0x016E
-// -0.013357
-0xFE4A
-// -0.026676
-0xFC96
-// -0.028766
-0xFC51
-// -0.016121
-0xFDF0
-// -0.002920
-0xFFA0
+// -0.012477
+0xFE67
+// -0.001757
+0xFFC6

Testing/Patterns/DSP/Filtering/FIR/FIRQ31/Coefs1_q31.txt

@@ -1,130 +1,130 @@
 W
 64
-// -0.440624
-0xC799A3CF
-// -0.020131
-0xFD6C565B
-// 0.223707
-0x1CA27034
-// -0.460865
-0xC502624D
-// 0.305483
-0x271A0DCB
-// -0.125994
-0xEFDF69E8
-// -0.345486
-0xD3C71E0B
-// -0.674560
-0xA9A8082A
-// -0.219192
-0xE3F1859B
-// -0.357393
-0xD240F284
-// -0.292593
-0xDA8C5276
-// -0.265881
-0xDDF79976
-// 0.523194
-0x42F803B3
-// 0.211665
-0x1B17D3CA
-// 0.161030
-0x149CA404
-// -0.609078
-0xB209B8C1
-// 0.054363
-0x06F559C1
-// 0.459718
-0x3AD80A04
-// 0.065876
-0x086EA12D
-// -0.318457
-0xD73CCCAB
-// -0.259414
-0xDECB894E
-// -0.528504
-0xBC59FE08
-// 0.103257
-0x0D3782D8
-// -0.204202
-0xE5DCB5F1
-// 0.361185
-0x2E3B4EB2
-// -0.134824
-0xEEBE166A
-// -0.002858
-0xFFA2580E
-// 0.440881
-0x386EC5B7
-// -0.597724
-0xB37DCBCE
-// 0.334700
-0x2AD7728D
-// 1.000000
-0x7FFFFFFF
-// -0.352092
-0xD2EEA8EC
-// -0.516010
-0xBDF362BE
-// 0.097020
-0x0C6B24F2
-// -0.307069
-0xD8B1F647
-// 0.265272
-0x21F471DC
-// -0.012420
-0xFE690941
-// -0.199806
-0xE66CBE59
-// -0.407294
-0xCBDDCDC2
-// 0.161555
-0x14ADD6B2
-// 0.265099
-0x21EEC1B4
-// -0.293503
-0xDA6E8266
-// -0.336242
-0xD4F60903
-// 0.315569
-0x28649271
-// 0.021360
-0x02BBED72
-// -0.048597
-0xF9C79437
-// -0.124846
-0xF0050A33
-// 0.275748
-0x234BB65F
-// -0.064471
-0xF7BF6840
-// -0.035854
-0xFB69229C
-// 0.074531
-0x098A39EC
-// -0.051416
-0xF96B2FDE
-// -0.262915
-0xDE58CD85
-// 0.188884
-0x182D56A7
-// -0.552953
-0xB938D79F
-// -0.055646
-0xF8E0967C
-// -0.449530
-0xC675CCBE
-// -0.096093
-0xF3B33745
-// -0.332864
-0xD564B2B2
-// 0.267353
-0x22389B80
-// 0.287500
-0x24CCCF37
-// 0.138693
-0x11C0AD8F
-// 0.194240
-0x18DCD8A5
-// 0.195224
-0x18FD183C
+// -0.191866
+0xE770EF3B
+// 0.222530
+0x1C7BD946
+// 0.206376
+0x1A6A896F
+// -0.149418
+0xECDFE1F5
+// -0.129398
+0xEF6FE462
+// -0.149487
+0xECDD9BB9
+// -0.045961
+0xFA1DF72B
+// -0.413630
+0xCB0E2C2F
+// -0.537612
+0xBB2F8498
+// -0.250407
+0xDFF2A79E
+// -0.358063
+0xD22AFF33
+// -0.473754
+0xC35C047E
+// 0.011042
+0x0169D69B
+// 0.264196
+0x21D12E0F
+// -1.000000
+0x80000000
+// -0.184288
+0xE8694075
+// 0.601710
+0x4D04D357
+// 0.290717
+0x2536350B
+// -0.200050
+0xE664C39F
+// -0.381631
+0xCF26B3D6
+// -0.798116
+0x99D753C5
+// 0.223667
+0x1CA12216
+// -0.780433
+0x9C1AC1B3
+// 0.430853
+0x372631D7
+// -0.253398
+0xDF90AA2D
+// 0.282587
+0x242BD0EC
+// -0.018847
+0xFD96680D
+// 0.611978
+0x4E554BD9
+// -0.546224
+0xBA155881
+// -0.231505
+0xE25E074B
+// 0.180850
+0x1726154C
+// 0.126927
+0x103F2737
+// -0.797792
+0x99E1F3CE
+// -0.323762
+0xD68EF7CE
+// -0.013639
+0xFE41122E
+// 0.500383
+0x400C8D26
+// 0.063050
+0x08120931
+// 0.065551
+0x0863FBDF
+// -0.202712
+0xE60D84FB
+// -0.160192
+0xEB7ED39A
+// 0.430357
+0x3715F0D6
+// -0.249012
+0xE0206094
+// 0.018343
+0x02590C38
+// -0.269687
+0xDD7AE39D
+// 0.045467
+0x05D1DC9D
+// 0.168227
+0x15887415
+// -0.773413
+0x9D00CD13
+// -0.483074
+0xC22A9FB6
+// 0.552749
+0x46C07DA6
+// -0.148772
+0xECF50E2E
+// -0.095485
+0xF3C72526
+// 0.463644
+0x3B58AC87
+// -0.309572
+0xD85FEF3C
+// 0.271522
+0x22C13A54
+// -0.472960
+0xC37608E3
+// 0.247024
+0x1F9E7B2C
+// 0.020090
+0x02924D23
+// -0.388815
+0xCE3B5045
+// 0.230698
+0x1D878330
+// -0.406822
+0xCBED3F37
+// -0.640629
+0xADFFE10B
+// 0.082108
+0x0A828041
+// -0.232218
+0xE246ABC6
+// -0.114530
+0xF157188D

Testing/Patterns/DSP/Filtering/FIR/FIRQ31/FirCoefs1_q31.txt

@@ -1,5 +1,449 @@
 W
-777
+999
+// 0.333333
+0x2AAAAAAB
+// 0.500000
+0x40000000
+// 0.250000
+0x20000000
+// 0.600000
+0x4CCCCCCD
+// 0.400000
+0x33333333
+// 0.200000
+0x1999999A
+// 0.666667
+0x55555555
+// 0.500000
+0x40000000
+// 0.333333
+0x2AAAAAAB
+// 0.166667
+0x15555555
+// 0.714286
+0x5B6DB6DB
+// 0.571429
+0x49249249
+// 0.428571
+0x36DB6DB7
+// 0.285714
+0x24924925
+// 0.142857
+0x12492492
+// 0.750000
+0x60000000
+// 0.625000
+0x50000000
+// 0.500000
+0x40000000
+// 0.375000
+0x30000000
+// 0.250000
+0x20000000
+// 0.125000
+0x10000000
+// 0.777778
+0x638E38E4
+// 0.666667
+0x55555555
+// 0.555556
+0x471C71C7
+// 0.444444
+0x38E38E39
+// 0.333333
+0x2AAAAAAB
+// 0.222222
+0x1C71C71C
+// 0.111111
+0x0E38E38E
+// 0.800000
+0x66666666
+// 0.700000
+0x5999999A
+// 0.600000
+0x4CCCCCCD
+// 0.500000
+0x40000000
+// 0.400000
+0x33333333
+// 0.300000
+0x26666666
+// 0.200000
+0x1999999A
+// 0.100000
+0x0CCCCCCD
+// 0.846154
+0x6C4EC4EC
+// 0.769231
+0x62762762
+// 0.692308
+0x589D89D9
+// 0.615385
+0x4EC4EC4F
+// 0.538462
+0x44EC4EC5
+// 0.461538
+0x3B13B13B
+// 0.384615
+0x313B13B1
+// 0.307692
+0x27627627
+// 0.230769
+0x1D89D89E
+// 0.153846
+0x13B13B14
+// 0.076923
+0x09D89D8A
+// 0.888889
+0x71C71C72
+// 0.833333
+0x6AAAAAAB
+// 0.777778
+0x638E38E4
+// 0.722222
+0x5C71C71C
+// 0.666667
+0x55555555
+// 0.611111
+0x4E38E38E
+// 0.555556
+0x471C71C7
+// 0.500000
+0x40000000
+// 0.444444
+0x38E38E39
+// 0.388889
+0x31C71C72
+// 0.333333
+0x2AAAAAAB
+// 0.277778
+0x238E38E4
+// 0.222222
+0x1C71C71C
+// 0.166667
+0x15555555
+// 0.111111
+0x0E38E38E
+// 0.055556
+0x071C71C7
+// 0.920000
+0x75C28F5C
+// 0.880000
+0x70A3D70A
+// 0.840000
+0x6B851EB8
+// 0.800000
+0x66666666
+// 0.760000
+0x6147AE14
+// 0.720000
+0x5C28F5C3
+// 0.680000
+0x570A3D71
+// 0.640000
+0x51EB851F
+// 0.600000
+0x4CCCCCCD
+// 0.560000
+0x47AE147B
+// 0.520000
+0x428F5C29
+// 0.480000
+0x3D70A3D7
+// 0.440000
+0x3851EB85
+// 0.400000
+0x33333333
+// 0.360000
+0x2E147AE1
+// 0.320000
+0x28F5C28F
+// 0.280000
+0x23D70A3D
+// 0.240000
+0x1EB851EC
+// 0.200000
+0x1999999A
+// 0.160000
+0x147AE148
+// 0.120000
+0x0F5C28F6
+// 0.080000
+0x0A3D70A4
+// 0.040000
+0x051EB852
+// 0.925926
+0x7684BDA1
+// 0.888889
+0x71C71C72
+// 0.851852
+0x6D097B42
+// 0.814815
+0x684BDA13
+// 0.777778
+0x638E38E4
+// 0.740741
+0x5ED097B4
+// 0.703704
+0x5A12F685
+// 0.666667
+0x55555555
+// 0.629630
+0x5097B426
+// 0.592593
+0x4BDA12F7
+// 0.555556
+0x471C71C7
+// 0.518519
+0x425ED098
+// 0.481481
+0x3DA12F68
+// 0.444444
+0x38E38E39
+// 0.407407
+0x3425ED09
+// 0.370370
+0x2F684BDA
+// 0.333333
+0x2AAAAAAB
+// 0.296296
+0x25ED097B
+// 0.259259
+0x212F684C
+// 0.222222
+0x1C71C71C
+// 0.185185
+0x17B425ED
+// 0.148148
+0x12F684BE
+// 0.111111
+0x0E38E38E
+// 0.074074
+0x097B425F
+// 0.037037
+0x04BDA12F
+// 0.333333
+0x2AAAAAAB
+// 0.500000
+0x40000000
+// 0.250000
+0x20000000
+// 0.600000
+0x4CCCCCCD
+// 0.400000
+0x33333333
+// 0.200000
+0x1999999A
+// 0.666667
+0x55555555
+// 0.500000
+0x40000000
+// 0.333333
+0x2AAAAAAB
+// 0.166667
+0x15555555
+// 0.714286
+0x5B6DB6DB
+// 0.571429
+0x49249249
+// 0.428571
+0x36DB6DB7
+// 0.285714
+0x24924925
+// 0.142857
+0x12492492
+// 0.750000
+0x60000000
+// 0.625000
+0x50000000
+// 0.500000
+0x40000000
+// 0.375000
+0x30000000
+// 0.250000
+0x20000000
+// 0.125000
+0x10000000
+// 0.777778
+0x638E38E4
+// 0.666667
+0x55555555
+// 0.555556
+0x471C71C7
+// 0.444444
+0x38E38E39
+// 0.333333
+0x2AAAAAAB
+// 0.222222
+0x1C71C71C
+// 0.111111
+0x0E38E38E
+// 0.800000
+0x66666666
+// 0.700000
+0x5999999A
+// 0.600000
+0x4CCCCCCD
+// 0.500000
+0x40000000
+// 0.400000
+0x33333333
+// 0.300000
+0x26666666
+// 0.200000
+0x1999999A
+// 0.100000
+0x0CCCCCCD
+// 0.846154
+0x6C4EC4EC
+// 0.769231
+0x62762762
+// 0.692308
+0x589D89D9
+// 0.615385
+0x4EC4EC4F
+// 0.538462
+0x44EC4EC5
+// 0.461538
+0x3B13B13B
+// 0.384615
+0x313B13B1
+// 0.307692
+0x27627627
+// 0.230769
+0x1D89D89E
+// 0.153846
+0x13B13B14
+// 0.076923
+0x09D89D8A
+// 0.888889
+0x71C71C72
+// 0.833333
+0x6AAAAAAB
+// 0.777778
+0x638E38E4
+// 0.722222
+0x5C71C71C
+// 0.666667
+0x55555555
+// 0.611111
+0x4E38E38E
+// 0.555556
+0x471C71C7
+// 0.500000
+0x40000000
+// 0.444444
+0x38E38E39
+// 0.388889
+0x31C71C72
+// 0.333333
+0x2AAAAAAB
+// 0.277778
+0x238E38E4
+// 0.222222
+0x1C71C71C
+// 0.166667
+0x15555555
+// 0.111111
+0x0E38E38E
+// 0.055556
+0x071C71C7
+// 0.920000
+0x75C28F5C
+// 0.880000
+0x70A3D70A
+// 0.840000
+0x6B851EB8
+// 0.800000
+0x66666666
+// 0.760000
+0x6147AE14
+// 0.720000
+0x5C28F5C3
+// 0.680000
+0x570A3D71
+// 0.640000
+0x51EB851F
+// 0.600000
+0x4CCCCCCD
+// 0.560000
+0x47AE147B
+// 0.520000
+0x428F5C29
+// 0.480000
+0x3D70A3D7
+// 0.440000
+0x3851EB85
+// 0.400000
+0x33333333
+// 0.360000
+0x2E147AE1
+// 0.320000
+0x28F5C28F
+// 0.280000
+0x23D70A3D
+// 0.240000
+0x1EB851EC
+// 0.200000
+0x1999999A
+// 0.160000
+0x147AE148
+// 0.120000
+0x0F5C28F6
+// 0.080000
+0x0A3D70A4
+// 0.040000
+0x051EB852
+// 0.925926
+0x7684BDA1
+// 0.888889
+0x71C71C72
+// 0.851852
+0x6D097B42
+// 0.814815
+0x684BDA13
+// 0.777778
+0x638E38E4
+// 0.740741
+0x5ED097B4
+// 0.703704
+0x5A12F685
+// 0.666667
+0x55555555
+// 0.629630
+0x5097B426
+// 0.592593
+0x4BDA12F7
+// 0.555556
+0x471C71C7
+// 0.518519
+0x425ED098
+// 0.481481
+0x3DA12F68
+// 0.444444
+0x38E38E39
+// 0.407407
+0x3425ED09
+// 0.370370
+0x2F684BDA
+// 0.333333
+0x2AAAAAAB
+// 0.296296
+0x25ED097B
+// 0.259259
+0x212F684C
+// 0.222222
+0x1C71C71C
+// 0.185185
+0x17B425ED
+// 0.148148
+0x12F684BE
+// 0.111111
+0x0E38E38E
+// 0.074074
+0x097B425F
+// 0.037037
+0x04BDA12F
 // 0.333333
 0x2AAAAAAB
 // 0.500000

Testing/Patterns/DSP/Filtering/FIR/FIRQ31/FirConfigs1_s16.txt

@@ -1,5 +1,5 @@
 H
-168
+216
 // 1
 0x0001
 // 1
@@ -192,6 +192,102 @@ H
 0x0008
 // 25
 0x0019
+// 9
+0x0009
+// 1
+0x0001
+// 9
+0x0009
+// 2
+0x0002
+// 9
+0x0009
+// 3
+0x0003
+// 9
+0x0009
+// 4
+0x0004
+// 9
+0x0009
+// 5
+0x0005
+// 9
+0x0009
+// 6
+0x0006
+// 9
+0x0009
+// 7
+0x0007
+// 9
+0x0009
+// 8
+0x0008
+// 9
+0x0009
+// 11
+0x000B
+// 9
+0x0009
+// 16
+0x0010
+// 9
+0x0009
+// 23
+0x0017
+// 9
+0x0009
+// 25
+0x0019
+// 10
+0x000A
+// 1
+0x0001
+// 10
+0x000A
+// 2
+0x0002
+// 10
+0x000A
+// 3
+0x0003
+// 10
+0x000A
+// 4
+0x0004
+// 10
+0x000A
+// 5
+0x0005
+// 10
+0x000A
+// 6
+0x0006
+// 10
+0x000A
+// 7
+0x0007
+// 10
+0x000A
+// 8
+0x0008
+// 10
+0x000A
+// 11
+0x000B
+// 10
+0x000A
+// 16
+0x0010
+// 10
+0x000A
+// 23
+0x0017
+// 10
+0x000A
+// 25
+0x0019
 // 11
 0x000B
 // 1

Testing/Patterns/DSP/Filtering/FIR/FIRQ31/FirInput1_q31.txt

@@ -1,94 +1,94 @@
 W
 46
-// -0.003873
-0xFF81168C
-// 0.024268
-0x031B3A42
-// 0.024660
-0x03280BBF
-// 0.027911
-0x039293ED
-// 0.013627
-0x01BE8924
-// -0.008456
-0xFEEAE8E9
-// -0.023941
-0xFCEF808D
-// -0.032154
-0xFBE2642B
-// -0.020861
-0xFD547094
-// 0.001171
-0x0026606D
-// 0.021925
-0x02CE704F
-// 0.033333
-0x04444444
-// 0.024564
-0x0324E980
-// 0.008567
-0x0118BAF0
-// -0.009969
-0xFEB958F7
-// -0.030217
-0xFC21DA86
-// -0.031584
-0xFBF50F40
-// -0.018218
-0xFDAB076B
-// 0.002632
-0x00563E0B
-// 0.016359
-0x02181047
-// 0.024703
-0x032978E1
-// 0.021687
-0x02C6A0A5
-// 0.013125
-0x01AE1449
-// -0.008506
-0xFEE946BB
-// -0.027839
-0xFC6FC77D
-// -0.029298
-0xFC3FF289
-// -0.019623
-0xFD7CFACA
-// -0.002645
-0xFFA9515C
-// 0.017370
-0x02392B64
-// 0.027617
-0x0388F4E1
-// 0.020920
-0x02AD8562
-// 0.007015
-0x00E5DFD7
-// -0.013133
-0xFE51A992
-// -0.024798
-0xFCD367D3
-// -0.030807
-0xFC0E8254
-// -0.019101
-0xFD8E1C05
-// 0.001001
-0x0020CFE4
-// 0.016366
-0x021846F6
-// 0.031099
-0x03FB0CAD
-// 0.022902
-0x02EE7313
-// 0.014917
-0x01E8D07D
-// -0.009200
-0xFED28BE3
-// -0.024455
-0xFCDEA8E1
-// -0.028957
-0xFC4B2275
-// -0.020109
-0xFD6D1023
-// -0.001448
-0xFFD08ECB
+// 0.001663
+0x00367EDA
+// 0.016691
+0x0222EDFF
+// 0.029040
+0x03B79801
+// 0.026452
+0x0362C3FF
+// 0.008223
+0x010D754A
+// -0.011213
+0xFE9091B0
+// -0.027874
+0xFC6EA009
+// -0.027070
+0xFC88FC88
+// -0.024169
+0xFCE808E1
+// -0.001581
+0xFFCC34C9
+// 0.019334
+0x0279887A
+// 0.030301
+0x03E0E7CE
+// 0.026993
+0x03747F9E
+// 0.010526
+0x0158E952
+// -0.009779
+0xFEBF8EB2
+// -0.025132
+0xFCC878DC
+// -0.033333
+0xFBBBBBBC
+// -0.018910
+0xFD945B6E
+// -0.001763
+0xFFC6390C
+// 0.014738
+0x01E2F09B
+// 0.031261
+0x04005A54
+// 0.026696
+0x036ACA57
+// 0.008836
+0x012185A6
+// -0.012442
+0xFE684B81
+// -0.023913
+0xFCF0675E
+// -0.031531
+0xFBF6C7B0
+// -0.019235
+0xFD89B125
+// -0.003438
+0xFF8F59AF
+// 0.019264
+0x02774213
+// 0.032802
+0x0432DCF9
+// 0.023045
+0x02F326A5
+// 0.009310
+0x01310EC9
+// -0.009332
+0xFECE3199
+// -0.028999
+0xFC49C17D
+// -0.030492
+0xFC18D2BB
+// -0.023167
+0xFD08DFD8
+// 0.000998
+0x0020B6F8
+// 0.018818
+0x02689E41
+// 0.029686
+0x03CCBCF8
+// 0.024215
+0x03197DBB
+// 0.014435
+0x01D901EE
+// -0.008714
+0xFEE27558
+// -0.028672
+0xFC547BF9
+// -0.026865
+0xFC8FAF2B
+// -0.022915
+0xFD111C84
+// 0.000247
+0x00081B7D

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/Coefs1_q7.txt

@@ -1,130 +1,130 @@
 B
 64
-// 0.402908
-0x34
-// 0.302983
-0x27
-// 0.260935
-0x21
-// 0.343689
+// 0.202012
+0x1A
+// 0.341042
+0x2C
+// -0.357644
+0xD2
+// 0.345808
 0x2C
-// -0.264464
+// 0.150474
+0x13
+// 0.155440
+0x14
+// -0.269035
 0xDE
-// 0.700369
-0x5A
-// 0.332854
-0x2B
-// 0.013080
-0x02
-// 0.063702
-0x08
-// 0.388992
-0x32
-// 0.056596
-0x07
-// 0.658643
-0x54
-// -0.828451
-0x96
-// -0.184320
-0xE8
-// -0.049089
-0xFA
-// 0.483794
-0x3E
-// -0.452257
-0xC6
-// -0.336909
-0xD5
-// -0.557898
-0xB9
-// 0.347278
+// -0.377972
+0xD0
+// -0.266107
+0xDE
+// -0.213272
+0xE5
+// 0.406665
+0x34
+// -0.092912
+0xF4
+// 0.234167
+0x1E
+// 0.195494
+0x19
+// -0.007514
+0xFF
+// -0.022323
+0xFD
+// -0.025666
+0xFD
+// 0.343841
 0x2C
-// 0.163892
-0x15
-// 0.377398
-0x30
-// 0.265331
-0x22
-// -0.313964
-0xD8
-// 0.464188
-0x3B
-// 0.164580
-0x15
-// -0.633644
-0xAF
-// -0.135763
-0xEF
-// -0.441118
-0xC8
-// 0.466063
+// -0.348503
+0xD3
+// -0.389054
+0xCE
+// 0.470504
 0x3C
-// -0.368841
-0xD1
-// 0.181286
-0x17
-// 0.113700
-0x0F
-// 0.336404
-0x2B
-// -0.798513
-0x9A
-// -0.003039
-0x00
-// -0.431600
-0xC9
-// -0.086413
-0xF5
-// -0.078176
+// 0.474321
+0x3D
+// 0.084093
+0x0B
+// -0.392630
+0xCE
+// -0.193773
+0xE7
+// -0.762108
+0x9E
+// -0.311842
+0xD8
+// -0.076381
 0xF6
-// 0.424517
-0x36
-// -0.104712
-0xF3
-// -0.372150
-0xD0
-// -0.159514
-0xEC
-// -0.467644
-0xC4
-// 0.785066
-0x64
-// -0.164054
-0xEB
-// -0.153906
-0xEC
-// 0.029627
-0x04
-// 0.530836
-0x44
-// 0.159785
+// 0.267142
+0x22
+// 0.152821
 0x14
-// -0.317170
-0xD7
-// -0.411475
-0xCB
-// 0.109241
-0x0E
-// 0.386141
-0x31
-// -0.516288
-0xBE
-// -0.167669
-0xEB
-// -0.351196
-0xD3
-// 0.227408
-0x1D
-// 0.115277
-0x0F
-// 1.000000
-0x7F
-// -0.191611
+// 0.430791
+0x37
+// -0.173700
+0xEA
+// -0.192104
 0xE7
-// -0.577609
-0xB6
-// -0.399011
+// -1.000000
+0x80
+// 0.474217
+0x3D
+// 0.113544
+0x0F
+// -0.063587
+0xF8
+// 0.153932
+0x14
+// -0.396244
 0xCD
-// 0.032922
-0x04
+// -0.620723
+0xB1
+// 0.293047
+0x26
+// 0.421956
+0x36
+// -0.362332
+0xD2
+// -0.612859
+0xB2
+// -0.402426
+0xCC
+// 0.374057
+0x30
+// -0.500077
+0xC0
+// 0.769351
+0x62
+// -0.263130
+0xDE
+// 0.152370
+0x14
+// -0.543964
+0xBA
+// -0.129939
+0xEF
+// -0.607642
+0xB2
+// 0.357848
+0x2E
+// -0.951675
+0x86
+// -0.083724
+0xF5
+// 0.128079
+0x10
+// -0.314895
+0xD8
+// -0.215859
+0xE4
+// 0.489583
+0x3F
+// -0.912592
+0x8B
+// 0.763485
+0x62
+// 0.333178
+0x2B
+// -0.071434
+0xF7

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/FirCoefs1_q7.txt

@@ -1,5 +1,293 @@
 B
-360
+504
+// 0.333333
+0x2B
+// 0.500000
+0x40
+// 0.250000
+0x20
+// 0.600000
+0x4D
+// 0.400000
+0x33
+// 0.200000
+0x1A
+// 0.666667
+0x55
+// 0.500000
+0x40
+// 0.333333
+0x2B
+// 0.166667
+0x15
+// 0.714286
+0x5B
+// 0.571429
+0x49
+// 0.428571
+0x37
+// 0.285714
+0x25
+// 0.142857
+0x12
+// 0.750000
+0x60
+// 0.625000
+0x50
+// 0.500000
+0x40
+// 0.375000
+0x30
+// 0.250000
+0x20
+// 0.125000
+0x10
+// 0.777778
+0x64
+// 0.666667
+0x55
+// 0.555556
+0x47
+// 0.444444
+0x39
+// 0.333333
+0x2B
+// 0.222222
+0x1C
+// 0.111111
+0x0E
+// 0.800000
+0x66
+// 0.700000
+0x5A
+// 0.600000
+0x4D
+// 0.500000
+0x40
+// 0.400000
+0x33
+// 0.300000
+0x26
+// 0.200000
+0x1A
+// 0.100000
+0x0D
+// 0.846154
+0x6C
+// 0.769231
+0x62
+// 0.692308
+0x59
+// 0.615385
+0x4F
+// 0.538462
+0x45
+// 0.461538
+0x3B
+// 0.384615
+0x31
+// 0.307692
+0x27
+// 0.230769
+0x1E
+// 0.153846
+0x14
+// 0.076923
+0x0A
+// 0.925926
+0x77
+// 0.888889
+0x72
+// 0.851852
+0x6D
+// 0.814815
+0x68
+// 0.777778
+0x64
+// 0.740741
+0x5F
+// 0.703704
+0x5A
+// 0.666667
+0x55
+// 0.629630
+0x51
+// 0.592593
+0x4C
+// 0.555556
+0x47
+// 0.518519
+0x42
+// 0.481481
+0x3E
+// 0.444444
+0x39
+// 0.407407
+0x34
+// 0.370370
+0x2F
+// 0.333333
+0x2B
+// 0.296296
+0x26
+// 0.259259
+0x21
+// 0.222222
+0x1C
+// 0.185185
+0x18
+// 0.148148
+0x13
+// 0.111111
+0x0E
+// 0.074074
+0x09
+// 0.037037
+0x05
+// 0.333333
+0x2B
+// 0.500000
+0x40
+// 0.250000
+0x20
+// 0.600000
+0x4D
+// 0.400000
+0x33
+// 0.200000
+0x1A
+// 0.666667
+0x55
+// 0.500000
+0x40
+// 0.333333
+0x2B
+// 0.166667
+0x15
+// 0.714286
+0x5B
+// 0.571429
+0x49
+// 0.428571
+0x37
+// 0.285714
+0x25
+// 0.142857
+0x12
+// 0.750000
+0x60
+// 0.625000
+0x50
+// 0.500000
+0x40
+// 0.375000
+0x30
+// 0.250000
+0x20
+// 0.125000
+0x10
+// 0.777778
+0x64
+// 0.666667
+0x55
+// 0.555556
+0x47
+// 0.444444
+0x39
+// 0.333333
+0x2B
+// 0.222222
+0x1C
+// 0.111111
+0x0E
+// 0.800000
+0x66
+// 0.700000
+0x5A
+// 0.600000
+0x4D
+// 0.500000
+0x40
+// 0.400000
+0x33
+// 0.300000
+0x26
+// 0.200000
+0x1A
+// 0.100000
+0x0D
+// 0.846154
+0x6C
+// 0.769231
+0x62
+// 0.692308
+0x59
+// 0.615385
+0x4F
+// 0.538462
+0x45
+// 0.461538
+0x3B
+// 0.384615
+0x31
+// 0.307692
+0x27
+// 0.230769
+0x1E
+// 0.153846
+0x14
+// 0.076923
+0x0A
+// 0.925926
+0x77
+// 0.888889
+0x72
+// 0.851852
+0x6D
+// 0.814815
+0x68
+// 0.777778
+0x64
+// 0.740741
+0x5F
+// 0.703704
+0x5A
+// 0.666667
+0x55
+// 0.629630
+0x51
+// 0.592593
+0x4C
+// 0.555556
+0x47
+// 0.518519
+0x42
+// 0.481481
+0x3E
+// 0.444444
+0x39
+// 0.407407
+0x34
+// 0.370370
+0x2F
+// 0.333333
+0x2B
+// 0.296296
+0x26
+// 0.259259
+0x21
+// 0.222222
+0x1C
+// 0.185185
+0x18
+// 0.148148
+0x13
+// 0.111111
+0x0E
+// 0.074074
+0x09
+// 0.037037
+0x05
 // 0.333333
 0x2B
 // 0.500000

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/FirConfigs1_s16.txt

@@ -1,5 +1,5 @@
 H
-100
+140
 // 1
 0x0001
 // 1
@@ -120,83 +120,163 @@ H
 0x0003
 // 25
 0x0019
-// 8
-0x0008
+// 20
+0x0014
 // 1
 0x0001
-// 8
-0x0008
+// 20
+0x0014
 // 2
 0x0002
-// 8
-0x0008
+// 20
+0x0014
 // 3
 0x0003
-// 8
-0x0008
+// 20
+0x0014
 // 4
 0x0004
-// 8
-0x0008
+// 20
+0x0014
 // 5
 0x0005
-// 8
-0x0008
+// 20
+0x0014
 // 6
 0x0006
-// 8
-0x0008
+// 20
+0x0014
 // 7
 0x0007
+// 20
+0x0014
 // 8
 0x0008
-// 8
-0x0008
-// 8
-0x0008
+// 20
+0x0014
 // 11
 0x000B
-// 8
-0x0008
+// 20
+0x0014
 // 25
 0x0019
-// 11
-0x000B
+// 21
+0x0015
 // 1
 0x0001
-// 11
-0x000B
+// 21
+0x0015
 // 2
 0x0002
-// 11
-0x000B
+// 21
+0x0015
 // 3
 0x0003
-// 11
-0x000B
+// 21
+0x0015
 // 4
 0x0004
-// 11
-0x000B
+// 21
+0x0015
 // 5
 0x0005
-// 11
-0x000B
+// 21
+0x0015
 // 6
 0x0006
-// 11
-0x000B
+// 21
+0x0015
 // 7
 0x0007
-// 11
-0x000B
+// 21
+0x0015
 // 8
 0x0008
+// 21
+0x0015
 // 11
 0x000B
+// 21
+0x0015
+// 25
+0x0019
+// 22
+0x0016
+// 1
+0x0001
+// 22
+0x0016
+// 2
+0x0002
+// 22
+0x0016
+// 3
+0x0003
+// 22
+0x0016
+// 4
+0x0004
+// 22
+0x0016
+// 5
+0x0005
+// 22
+0x0016
+// 6
+0x0006
+// 22
+0x0016
+// 7
+0x0007
+// 22
+0x0016
+// 8
+0x0008
+// 22
+0x0016
 // 11
 0x000B
+// 22
+0x0016
+// 25
+0x0019
+// 23
+0x0017
+// 1
+0x0001
+// 23
+0x0017
+// 2
+0x0002
+// 23
+0x0017
+// 3
+0x0003
+// 23
+0x0017
+// 4
+0x0004
+// 23
+0x0017
+// 5
+0x0005
+// 23
+0x0017
+// 6
+0x0006
+// 23
+0x0017
+// 7
+0x0007
+// 23
+0x0017
+// 8
+0x0008
+// 23
+0x0017
 // 11
 0x000B
+// 23
+0x0017
 // 25
 0x0019

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/FirInput1_q7.txt

@@ -1,94 +1,94 @@
 B
 46
-// 0.000367
+// 0.000847
 0x00
-// 0.018210
+// 0.017058
 0x02
-// 0.030434
+// 0.031844
 0x04
-// 0.024524
+// 0.024217
 0x03
-// 0.013149
+// 0.012015
 0x02
-// -0.014928
+// -0.012772
 0xFE
-// -0.028519
-0xFC
-// -0.029113
+// -0.027046
+0xFD
+// -0.030377
 0xFC
-// -0.021481
+// -0.020112
 0xFD
-// -0.000977
+// -0.000589
 0x00
-// 0.024664
-0x03
-// 0.027586
-0x04
-// 0.029135
+// 0.017576
+0x02
+// 0.029721
 0x04
-// 0.010401
-0x01
-// -0.009060
+// 0.025408
+0x03
+// 0.013475
+0x02
+// -0.009069
 0xFF
-// -0.027148
+// -0.025536
 0xFD
-// -0.029180
-0xFC
-// -0.020006
+// -0.026819
 0xFD
-// -0.001987
+// -0.013519
+0xFE
+// 0.000687
 0x00
-// 0.018935
-0x02
-// 0.033333
-0x04
-// 0.025619
+// 0.024224
 0x03
-// 0.010810
+// 0.031745
+0x04
+// 0.030801
+0x04
+// 0.010035
 0x01
-// -0.008588
+// -0.007864
 0xFF
-// -0.028150
+// -0.027438
 0xFC
-// -0.030828
+// -0.030032
 0xFC
-// -0.021272
+// -0.019767
 0xFD
-// 0.001683
-0x00
-// 0.023511
+// 0.005137
+0x01
+// 0.022832
 0x03
-// 0.032976
+// 0.029697
 0x04
-// 0.024043
+// 0.026101
 0x03
-// 0.010782
+// 0.011125
 0x01
-// -0.012400
-0xFE
-// -0.024030
-0xFD
-// -0.026964
-0xFD
-// -0.020223
+// -0.010608
+0xFF
+// -0.031036
+0xFC
+// -0.028402
+0xFC
+// -0.021481
 0xFD
-// -0.001965
+// 0.002655
 0x00
-// 0.019417
+// 0.015670
 0x02
-// 0.031812
+// 0.028916
 0x04
-// 0.024889
+// 0.025253
 0x03
-// 0.006053
-0x01
-// -0.010002
+// 0.012441
+0x02
+// -0.008983
 0xFF
-// -0.030038
-0xFC
-// -0.030342
+// -0.026192
+0xFD
+// -0.033333
 0xFC
-// -0.019449
+// -0.018952
 0xFE
-// -0.001060
+// 0.000727
 0x00

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/Refs1_q7.txt

@@ -1,514 +1,514 @@
 B
 256
-// -0.350063
-0xD3
-// -0.359355
-0xD2
-// 0.432898
-0x37
-// -0.410620
-0xCB
-// -0.235031
-0xE2
-// -0.697074
-0xA7
-// 0.646466
-0x53
-// 0.288383
-0x25
-// 0.084201
-0x0B
-// -0.299550
-0xDA
-// 0.254983
-0x21
-// -0.047046
-0xFA
-// -0.652118
-0xAD
-// -0.427166
-0xC9
-// 0.224017
-0x1D
-// -0.810767
-0x98
-// 0.007052
-0x01
-// -0.637262
-0xAE
-// -0.362971
-0xD2
-// -0.249505
-0xE0
-// -0.413789
-0xCB
-// -0.957286
-0x85
-// 0.550748
-0x46
-// 0.278529
-0x24
-// 0.902547
-0x74
-// -0.133181
+// 0.367663
+0x2F
+// -0.088021
+0xF5
+// -0.134802
 0xEF
-// -0.197827
-0xE7
-// 0.021839
-0x03
-// 0.188603
-0x18
-// -0.556203
-0xB9
-// 0.818998
-0x69
-// -0.363088
-0xD2
-// -0.009319
-0xFF
-// -0.834437
-0x95
-// 0.046253
+// 0.049610
 0x06
-// -0.392918
-0xCE
-// -0.460027
-0xC5
-// 0.248801
-0x20
-// 0.522869
-0x43
-// 0.331302
-0x2A
-// 0.340223
-0x2C
-// 0.893737
-0x72
-// 0.567596
-0x49
-// -0.258867
+// -0.257613
 0xDF
-// 0.377568
+// 0.012289
+0x02
+// 0.373298
 0x30
-// 0.270526
-0x23
-// -0.015793
-0xFE
-// -0.358719
-0xD2
-// -0.027515
+// -0.153002
+0xEC
+// 0.055876
+0x07
+// 0.262302
+0x22
+// -0.191905
+0xE7
+// 0.162540
+0x15
+// -0.024115
+0xFD
+// -0.088350
+0xF5
+// 0.102864
+0x0D
+// -0.450945
+0xC6
+// -0.146112
+0xED
+// 0.222110
+0x1C
+// 0.089926
+0x0C
+// -0.029351
 0xFC
-// 0.329488
-0x2A
-// 0.173102
+// -0.794616
+0x9A
+// 0.163133
+0x15
+// -0.114454
+0xF1
+// -0.026332
+0xFD
+// -0.548344
+0xBA
+// -0.661619
+0xAB
+// 0.083208
+0x0B
+// -0.667615
+0xAB
+// -0.060329
+0xF8
+// -0.242687
+0xE1
+// -0.624722
+0xB0
+// -0.324566
+0xD6
+// -0.613083
+0xB2
+// 0.490669
+0x3F
+// 0.015650
+0x02
+// 0.230874
+0x1E
+// -0.264091
+0xDE
+// 0.437759
+0x38
+// -0.579335
+0xB6
+// 0.117110
+0x0F
+// -0.134724
+0xEF
+// 0.173164
 0x16
-// 0.427848
-0x37
-// -0.001894
-0x00
-// 0.176895
+// 0.175878
 0x17
-// -0.144018
-0xEE
-// -0.414544
-0xCB
-// -0.353723
-0xD3
-// -0.272371
-0xDD
-// -0.358185
-0xD2
-// 0.190347
-0x18
-// 0.035276
-0x05
-// -0.136841
-0xEE
-// 0.206321
-0x1A
-// 0.137521
-0x12
-// 0.002225
-0x00
-// -0.345676
+// -0.281644
+0xDC
+// -0.342953
 0xD4
-// -0.491556
-0xC1
-// -0.053000
-0xF9
-// -0.079450
-0xF6
-// 0.288453
-0x25
-// 0.369592
-0x2F
-// 0.122079
-0x10
-// 0.437364
-0x38
-// 0.065104
-0x08
-// -0.387653
-0xCE
-// 0.137682
-0x12
-// -0.276030
-0xDD
-// 0.230400
-0x1D
-// 0.110832
+// -0.322392
+0xD7
+// 0.258189
+0x21
+// -0.106423
+0xF2
+// -0.068161
+0xF7
+// 0.057771
+0x07
+// -0.806191
+0x99
+// 0.681253
+0x57
+// -0.157885
+0xEC
+// 0.107580
 0x0E
-// -0.522204
-0xBD
-// 0.009207
-0x01
-// -0.890263
-0x8E
-// -0.181269
-0xE9
-// 0.333919
-0x2B
-// 0.513723
-0x42
-// -0.074614
+// -0.288685
+0xDB
+// -0.572822
+0xB7
+// 0.067899
+0x09
+// -0.237430
+0xE2
+// -0.100637
+0xF3
+// 0.232455
+0x1E
+// 0.694542
+0x59
+// -0.031915
+0xFC
+// -0.018270
+0xFE
+// 0.421725
+0x36
+// 0.161871
+0x15
+// -0.231585
+0xE2
+// -0.419282
+0xCA
+// -0.106606
+0xF2
+// -0.078699
 0xF6
-// 0.039408
-0x05
-// 0.512073
-0x42
-// -0.565618
-0xB8
-// 0.134681
-0x11
-// -0.317896
-0xD7
-// -1.000000
-0x80
-// 0.443289
-0x39
-// -0.082167
+// 0.092119
+0x0C
+// 0.315995
+0x28
+// -0.082862
 0xF5
-// 0.520966
-0x43
-// 0.376426
-0x30
-// -0.075895
-0xF6
-// -0.396055
-0xCD
-// -0.586501
-0xB5
-// 0.808975
-0x68
-// 0.132605
+// 0.766553
+0x62
+// -0.247643
+0xE0
+// -0.054912
+0xF9
+// -0.683128
+0xA9
+// -0.054775
+0xF9
+// -0.031253
+0xFC
+// 0.130006
 0x11
-// -0.262980
-0xDE
-// -0.298503
-0xDA
-// 0.317059
-0x29
-// -0.498134
-0xC0
-// 0.329967
-0x2A
-// -0.217401
+// 0.571471
+0x49
+// 0.167377
+0x15
+// 0.425352
+0x36
+// -0.272251
+0xDD
+// 0.545262
+0x46
+// -0.490118
+0xC1
+// -0.051377
+0xF9
+// -0.008938
+0xFF
+// 0.925956
+0x77
+// 0.166611
+0x15
+// -0.217528
 0xE4
-// -0.157298
-0xEC
-// -0.477586
-0xC3
-// -0.070500
-0xF7
-// -0.138174
+// 0.429243
+0x37
+// 0.333351
+0x2B
+// 0.276058
+0x23
+// 0.436316
+0x38
+// -0.355418
+0xD3
+// -0.163917
+0xEB
+// 0.097067
+0x0C
+// 0.212976
+0x1B
+// 0.311948
+0x28
+// 0.095193
+0x0C
+// -0.631748
+0xAF
+// 0.123978
+0x10
+// 0.478728
+0x3D
+// -0.514141
+0xBE
+// 0.074273
+0x0A
+// -0.151432
+0xED
+// 0.274590
+0x23
+// -0.439729
+0xC8
+// -0.373502
+0xD0
+// 0.555353
+0x47
+// -0.083294
+0xF5
+// -0.087964
+0xF5
+// 0.254586
+0x21
+// -0.112109
+0xF2
+// 0.759314
+0x61
+// 0.203876
+0x1A
+// 0.726262
+0x5D
+// -0.282262
+0xDC
+// -0.545372
+0xBA
+// -0.432888
+0xC9
+// -0.300990
+0xD9
+// 0.360750
+0x2E
+// -0.123393
+0xF0
+// -0.172862
+0xEA
+// -0.734416
+0xA2
+// 0.260192
+0x21
+// -0.143166
 0xEE
-// 0.035518
-0x05
-// 0.216394
-0x1C
-// -0.008920
+// 0.633446
+0x51
+// -0.211159
+0xE5
+// 0.136365
+0x11
+// -0.364549
+0xD1
+// 0.250890
+0x20
+// 0.052490
+0x07
+// -0.185813
+0xE8
+// -0.004770
 0xFF
-// 0.154938
+// -0.217738
+0xE4
+// -0.176698
+0xE9
+// -0.611272
+0xB2
+// -0.198168
+0xE7
+// 0.005052
+0x01
+// -0.252784
+0xE0
+// -0.012577
+0xFE
+// 0.147779
+0x13
+// -0.226898
+0xE3
+// 0.152504
 0x14
-// -0.072765
-0xF7
-// 0.389005
-0x32
-// 0.532540
-0x44
-// 0.794035
-0x66
-// -0.371526
-0xD0
-// 0.211993
-0x1B
-// -0.454263
-0xC6
-// -0.152440
-0xEC
-// -0.103354
+// 0.314921
+0x28
+// 0.248865
+0x20
+// 0.124318
+0x10
+// 0.265066
+0x22
+// 0.295543
+0x26
+// 0.279446
+0x24
+// -0.446225
+0xC7
+// -0.081532
+0xF6
+// -0.521630
+0xBD
+// 0.335994
+0x2B
+// -0.119689
+0xF1
+// 0.013798
+0x02
+// -0.435308
+0xC8
+// 0.424077
+0x36
+// -0.102917
 0xF3
-// 0.051405
+// 0.293257
+0x26
+// -0.015989
+0xFE
+// 0.052967
 0x07
-// 0.819983
-0x69
-// -0.830960
-0x96
-// 0.497098
-0x40
-// -0.495422
-0xC1
-// -0.589325
-0xB5
-// 0.433306
-0x37
-// 0.148103
-0x13
-// -0.011122
-0xFF
-// 0.107693
-0x0E
-// -0.233574
-0xE2
-// 0.239502
+// 0.239275
 0x1F
-// 0.313413
-0x28
-// -0.728741
-0xA3
-// 0.816048
-0x68
-// 0.413658
-0x35
-// 0.181556
-0x17
-// 0.800210
-0x66
-// 0.678251
-0x57
-// -0.059705
-0xF8
-// 0.389972
-0x32
-// -0.170898
-0xEA
-// 0.419247
+// 0.348940
+0x2D
+// 0.374363
+0x30
+// -0.515563
+0xBE
+// -0.215935
+0xE4
+// 0.421720
 0x36
-// -0.058998
-0xF8
-// 0.772377
-0x63
-// 0.155642
-0x14
-// 0.217131
-0x1C
-// -0.127787
-0xF0
-// -0.528872
-0xBC
-// 0.484950
-0x3E
-// -0.253115
-0xE0
-// 0.573060
-0x49
-// -0.634900
-0xAF
-// 0.253857
-0x20
-// 0.093590
-0x0C
-// 0.139178
-0x12
-// -0.151417
-0xED
-// -0.307031
-0xD9
-// -0.083533
-0xF5
-// 0.076245
+// 0.076518
 0x0A
-// 0.179467
-0x17
-// 0.096709
-0x0C
-// 0.170670
-0x16
-// 0.409140
-0x34
-// 0.582941
-0x4B
-// 0.650421
-0x53
-// -0.836426
-0x95
-// -0.029671
-0xFC
-// 0.426416
-0x37
-// -0.438566
-0xC8
-// 0.140565
-0x12
-// 0.024372
-0x03
-// -0.112013
+// 0.235478
+0x1E
+// 0.157948
+0x14
+// -0.113100
 0xF2
-// 0.108489
-0x0E
-// 0.252779
-0x20
-// 0.239195
+// 0.019674
+0x03
+// 0.239009
 0x1F
-// -0.618914
-0xB1
-// -0.123471
-0xF0
-// -0.641053
-0xAE
-// 0.219804
+// 0.983348
+0x7E
+// 0.236942
+0x1E
+// 0.116180
+0x0F
+// -0.027734
+0xFC
+// 0.658369
+0x54
+// 0.203085
+0x1A
+// 0.345405
+0x2C
+// 0.176282
+0x17
+// -0.478782
+0xC3
+// -0.100725
+0xF3
+// 0.748184
+0x60
+// -0.064116
+0xF8
+// -0.159234
+0xEC
+// -0.467859
+0xC4
+// -0.019303
+0xFE
+// 0.066433
+0x09
+// 0.139403
+0x12
+// 0.276242
+0x23
+// 0.134792
+0x11
+// -0.369585
+0xD1
+// -0.187603
+0xE8
+// 0.142075
+0x12
+// 0.215876
 0x1C
-// 0.090792
-0x0C
-// 0.089094
-0x0B
-// -0.150465
-0xED
-// -0.424937
-0xCA
-// 0.037090
-0x05
-// 0.059408
-0x08
-// -0.192774
-0xE7
-// -0.867765
-0x91
-// 0.161824
-0x15
-// -0.352048
-0xD3
-// 0.064521
-0x08
-// -0.541103
+// 0.413275
+0x35
+// 0.118332
+0x0F
+// 0.143610
+0x12
+// 0.054558
+0x07
+// -0.157072
+0xEC
+// 0.220222
+0x1C
+// -0.368290
+0xD1
+// -0.581428
+0xB6
+// 0.078942
+0x0A
+// -0.538024
 0xBB
-// 0.687565
-0x58
-// -0.095815
+// -0.094690
 0xF4
-// 0.328557
-0x2A
-// 0.544142
-0x46
-// -0.623791
-0xB0
-// 0.632342
-0x51
-// 0.113167
-0x0E
-// 0.161896
-0x15
-// 0.853637
-0x6D
-// 0.661551
-0x55
-// 0.036377
+// 0.040620
 0x05
-// 0.004701
-0x01
-// -0.067624
-0xF7
-// 0.210677
-0x1B
-// 0.160735
+// -0.346148
+0xD4
+// 0.277859
+0x24
+// -0.076717
+0xF6
+// -0.004388
+0xFF
+// -0.613801
+0xB1
+// -0.097355
+0xF4
+// -0.539259
+0xBB
+// -0.198327
+0xE7
+// 0.160599
 0x15
-// 0.105905
-0x0E
-// 0.694248
-0x59
-// 0.020220
-0x03
-// 0.249606
+// -0.283558
+0xDC
+// 0.766909
+0x62
+// -0.946393
+0x87
+// 0.737270
+0x5E
+// 0.379599
+0x31
+// 0.081556
+0x0A
+// -0.801258
+0x99
+// -0.699283
+0xA6
+// 0.247835
 0x20
-// 0.391483
-0x32
-// 0.154314
-0x14
-// -0.106673
-0xF2
-// -0.101201
-0xF3
-// -0.305525
-0xD9
-// 0.143561
+// -0.040493
+0xFB
+// -0.268922
+0xDE
+// 0.138070
 0x12
-// -0.466415
-0xC4
-// 0.091098
-0x0C
-// 0.003229
-0x00
-// -0.446768
-0xC7
-// 0.090523
-0x0C
-// 0.009806
+// 0.004940
 0x01
-// 0.154948
-0x14
-// -0.180637
-0xE9
-// 0.223434
-0x1D
-// -0.107680
-0xF2
-// -0.062028
+// -0.049107
+0xFA
+// -0.062050
 0xF8
-// 0.097722
-0x0D
-// 0.015594
-0x02
-// -0.447499
-0xC7
-// -0.259110
-0xDF
-// 0.431084
+// 0.303572
+0x27
+// 0.072560
+0x09
+// -0.167205
+0xEB
+// 0.010028
+0x01
+// 0.127722
+0x10
+// -0.240498
+0xE1
+// 0.683719
+0x58
+// -0.687214
+0xA8
+// -0.209878
+0xE5
+// 0.223823
+0x1D
+// -0.265197
+0xDE
+// 0.254285
+0x21
+// -0.371124
+0xD0
+// -0.086337
+0xF5
+// -0.135328
+0xEF
+// 0.425791
 0x37
-// 0.152343
-0x13
-// 0.388254
-0x32
-// -0.794644
-0x9A
-// -0.383528
-0xCF
-// -0.078877
-0xF6
-// 0.240602
-0x1F
-// -0.109552
-0xF2
-// -0.119527
-0xF1
-// 0.170055
-0x16
-// -0.472767
-0xC3
-// 0.136111
-0x11
-// -0.764617
-0x9E
-// 0.313232
+// 0.316118
 0x28
-// -0.134713
-0xEF
-// -0.706310
-0xA6
-// 0.171819
-0x16
-// 0.083707
-0x0B
-// 0.284367
-0x24
-// -0.340644
-0xD4
+// 0.162272
+0x15
+// -0.206432
+0xE6
+// -1.000000
+0x80
+// 0.034253
+0x04
+// 0.110999
+0x0E

Testing/Patterns/DSP/Filtering/FIR/FIRQ7/Samples1_q7.txt

@@ -1,514 +1,514 @@
 B
 256
-// 0.437167
-0x38
-// 0.900863
-0x73
-// -0.165573
-0xEB
-// -0.867605
-0x91
-// 0.300775
-0x26
-// 0.004007
-0x01
-// 0.728558
-0x5D
-// 0.049256
-0x06
-// 0.658192
-0x54
-// -0.007081
-0xFF
-// -0.132565
-0xEF
-// -0.799263
-0x9A
-// 0.328879
+// 0.214821
+0x1B
+// 0.279390
+0x24
+// 0.505281
+0x41
+// 0.221068
+0x1C
+// 0.153282
+0x14
+// 0.264950
+0x22
+// -0.340615
+0xD4
+// -0.023215
+0xFD
+// -0.273978
+0xDD
+// 0.324489
 0x2A
-// 0.029151
+// 0.032313
 0x04
-// -0.338076
-0xD5
-// -0.048099
-0xFA
-// 0.309885
-0x28
-// 0.454834
-0x3A
-// -0.421019
-0xCA
-// 0.550065
-0x46
-// -0.280132
-0xDC
-// 0.311139
-0x28
-// 0.201152
-0x1A
-// 0.499458
-0x40
-// -0.453239
-0xC6
-// 0.146378
-0x13
-// 0.077906
-0x0A
-// 0.559085
-0x48
-// 0.554451
-0x47
-// -0.572934
-0xB7
-// -0.943801
-0x87
-// -0.224047
-0xE3
-// 0.051079
-0x07
-// 0.060345
-0x08
-// 0.607492
-0x4E
-// 0.131652
+// 0.224594
+0x1D
+// 0.234979
+0x1E
+// -0.663019
+0xAB
+// 0.028831
+0x04
+// 0.026800
+0x03
+// -0.727313
+0xA3
+// -0.345116
+0xD4
+// -0.479008
+0xC3
+// 0.134598
 0x11
-// -0.452184
-0xC6
-// -0.145147
-0xED
-// 0.362008
-0x2E
-// -0.324199
-0xD7
-// 0.115850
-0x0F
-// -0.130694
-0xEF
-// -0.280819
-0xDC
-// -0.536923
-0xBB
-// -0.649202
-0xAD
-// -0.450889
-0xC6
-// -0.194088
-0xE7
-// -0.039922
+// -0.038428
 0xFB
-// -0.421229
-0xCA
-// -0.024564
-0xFD
-// 0.036891
-0x05
-// 0.183446
+// 0.207319
+0x1B
+// 0.180725
 0x17
-// 0.484712
-0x3E
-// -0.085706
+// -0.126952
+0xF0
+// -0.154457
+0xEC
+// 0.096711
+0x0C
+// -0.362711
+0xD2
+// -0.358553
+0xD2
+// -0.084916
 0xF5
-// -0.825592
-0x96
-// -0.186796
-0xE8
-// -0.733002
-0xA2
-// 0.419869
-0x36
-// 0.029537
-0x04
-// 0.447962
-0x39
-// 0.315936
-0x28
-// 0.696782
-0x59
-// 0.168592
-0x16
-// -0.014565
-0xFE
-// 0.551439
-0x47
-// -0.262806
+// -0.375251
+0xD0
+// 0.322710
+0x29
+// -0.408494
+0xCC
+// -0.055599
+0xF9
+// 0.249500
+0x20
+// -0.266946
 0xDE
-// -0.335101
-0xD5
-// 0.310447
-0x28
-// 0.395844
-0x33
-// -0.105800
+// 0.487438
+0x3E
+// 0.142946
+0x12
+// -0.681367
+0xA9
+// -0.109805
 0xF2
-// 0.144777
+// 0.354165
+0x2D
+// -0.428746
+0xC9
+// 0.149633
 0x13
-// -0.268058
-0xDE
-// 0.014434
-0x02
-// -0.261852
-0xDE
-// -0.749291
-0xA0
-// 0.111629
-0x0E
-// 0.238159
+// -0.147395
+0xED
+// 0.426211
+0x37
+// -0.058229
+0xF9
+// 0.298193
+0x26
+// -0.240207
+0xE1
+// -0.168731
+0xEA
+// 0.129925
+0x11
+// 0.220875
+0x1C
+// 0.232109
 0x1E
-// 0.408691
-0x34
-// -0.126157
-0xF0
-// 0.529823
-0x44
-// -0.179612
-0xE9
-// -0.154707
-0xEC
-// 0.411845
-0x35
-// 0.362818
-0x2E
-// 0.278319
-0x24
-// 0.061497
-0x08
-// 0.116019
-0x0F
-// 0.636167
-0x51
-// 0.443167
-0x39
-// 0.651606
-0x53
-// 0.186785
-0x18
-// 0.420678
-0x36
-// 0.277391
-0x24
-// 0.082715
-0x0B
-// 0.361721
-0x2E
-// -0.008436
-0xFF
-// 0.241027
-0x1F
-// 0.356424
-0x2E
-// 0.591141
-0x4C
-// -0.256156
+// 0.474162
+0x3D
+// -0.029493
+0xFC
+// -0.002503
+0x00
+// -0.258340
 0xDF
-// -0.143766
+// -0.094590
+0xF4
+// -0.136977
 0xEE
-// 0.016045
-0x02
-// 0.091159
-0x0C
-// 0.083606
-0x0B
-// 0.054741
-0x07
-// -0.361596
-0xD2
-// 0.087600
-0x0B
-// 0.337698
-0x2B
-// -0.230265
-0xE3
-// 0.676945
-0x57
-// 0.069378
-0x09
-// 0.135760
-0x11
-// 0.073174
-0x09
-// -0.393425
-0xCE
-// -0.268259
-0xDE
-// -0.080380
+// -0.575244
+0xB6
+// -0.152733
+0xEC
+// -0.207893
+0xE5
+// -0.347410
+0xD4
+// -0.758313
+0x9F
+// -0.076478
 0xF6
-// 0.247835
-0x20
-// 0.348419
-0x2D
-// 0.006349
-0x01
-// -0.072362
-0xF7
-// -0.228134
-0xE3
-// 0.311650
+// 0.216700
+0x1C
+// 0.047021
+0x06
+// 0.067844
+0x09
+// 0.314853
 0x28
-// 0.209872
-0x1B
-// -0.155600
-0xEC
-// 0.021184
-0x03
-// -0.100698
-0xF3
-// -0.072403
-0xF7
-// 0.677051
-0x57
-// 0.416999
-0x35
-// -0.284411
-0xDC
-// 0.058450
-0x07
-// -0.177395
-0xE9
-// -0.456433
-0xC6
-// -0.050412
-0xFA
-// -0.791437
-0x9B
-// -0.261101
-0xDF
-// -0.466526
-0xC4
-// 0.244900
-0x1F
-// 0.111823
-0x0E
-// -0.465401
+// -0.277202
+0xDD
+// -0.000657
+0x00
+// 0.410032
+0x34
+// -0.290286
+0xDB
+// -0.143428
+0xEE
+// 0.592873
+0x4C
+// 0.201206
+0x1A
+// 0.199789
+0x1A
+// -0.465313
 0xC4
-// 0.868605
-0x6F
-// 0.370285
-0x2F
-// -0.146579
-0xED
-// 0.105215
-0x0D
-// -0.576766
-0xB6
-// 0.266103
-0x22
-// -0.067157
-0xF7
-// -0.027048
-0xFD
-// -0.370069
-0xD1
-// -0.185785
+// -0.188626
 0xE8
-// 0.006277
-0x01
-// 0.931296
-0x77
-// -0.104897
-0xF3
-// -0.703905
-0xA6
-// 0.183407
-0x17
-// -0.133320
+// 0.466207
+0x3C
+// -0.140446
+0xEE
+// -0.394756
+0xCD
+// 0.167113
+0x15
+// 0.640062
+0x52
+// -0.522529
+0xBD
+// -0.329548
+0xD6
+// -0.566747
+0xB7
+// 0.759046
+0x61
+// 0.053660
+0x07
+// -0.218345
+0xE4
+// -0.943581
+0x87
+// -0.374487
+0xD0
+// 0.318072
+0x29
+// 0.097424
+0x0C
+// 0.224305
+0x1D
+// 0.411233
+0x35
+// -0.271870
+0xDD
+// -0.250968
+0xE0
+// 0.232076
+0x1E
+// 0.169544
+0x16
+// 0.036189
+0x05
+// 0.035148
+0x04
+// -0.364830
+0xD1
+// -0.246951
+0xE0
+// 0.690011
+0x58
+// -0.364251
+0xD1
+// 0.651377
+0x53
+// 0.036243
+0x05
+// -0.359996
+0xD2
+// -0.133487
 0xEF
-// 0.429109
-0x37
-// 0.044620
-0x06
-// 0.717697
-0x5C
-// 1.000000
-0x7F
-// 0.557157
-0x47
-// 0.158588
+// 0.415672
+0x35
+// 0.613107
+0x4E
+// 0.104502
+0x0D
+// -0.401692
+0xCD
+// -0.492679
+0xC1
+// 0.154957
 0x14
-// -0.732348
-0xA2
-// 0.515111
-0x42
-// -0.025143
-0xFD
-// 0.160811
-0x15
-// 0.368131
-0x2F
-// -0.244720
-0xE1
-// -0.737671
-0xA2
-// -0.355054
-0xD3
-// -0.082841
-0xF5
-// -0.226852
-0xE3
-// 0.295844
+// 0.224994
+0x1D
+// -0.001646
+0x00
+// -0.780340
+0x9C
+// -0.160156
+0xEC
+// 0.194944
+0x19
+// 0.301090
+0x27
+// 0.093471
+0x0C
+// -0.462750
+0xC5
+// -0.011944
+0xFE
+// -0.333955
+0xD5
+// 0.084301
+0x0B
+// 0.090313
+0x0C
+// 0.023580
+0x03
+// -0.144447
+0xEE
+// 0.295394
 0x26
-// 0.117660
+// -0.014906
+0xFE
+// -0.007951
+0xFF
+// -0.168962
+0xEA
+// 0.089135
+0x0B
+// 0.019085
+0x02
+// -0.098830
+0xF3
+// -0.379502
+0xCF
+// 0.149659
+0x13
+// 0.194886
+0x19
+// 0.114820
 0x0F
-// 0.546173
-0x46
-// -0.055551
-0xF9
-// 0.401036
+// 0.338924
+0x2B
+// 0.208755
+0x1B
+// -0.318815
+0xD7
+// 0.258304
+0x21
+// -0.037152
+0xFB
+// 0.176532
+0x17
+// 0.396706
 0x33
-// -0.223341
-0xE3
-// -0.116624
-0xF1
-// -0.393899
-0xCE
-// -0.409412
-0xCC
-// 0.285002
-0x24
-// -0.630636
-0xAF
-// 0.299348
-0x26
-// -0.006331
-0xFF
-// 0.024793
-0x03
-// 0.303130
-0x27
-// 0.142486
+// 0.117858
+0x0F
+// -0.079924
+0xF6
+// 0.142941
 0x12
-// -0.347861
-0xD3
-// -0.162271
-0xEB
-// 0.385909
-0x31
-// -0.233828
-0xE2
-// -0.553446
-0xB9
-// 0.061986
-0x08
-// 0.097745
-0x0D
-// -0.231477
-0xE2
-// 0.718095
-0x5C
-// 0.161169
-0x15
-// 0.196409
-0x19
-// -0.198866
-0xE7
-// -0.569369
-0xB7
-// 0.572038
-0x49
-// -0.416034
-0xCB
-// -0.128443
-0xF0
-// -0.619759
-0xB1
-// -0.050332
+// 0.068514
+0x09
+// -0.048384
 0xFA
-// 0.087366
-0x0B
-// 0.270080
-0x23
-// -0.277682
-0xDC
-// -0.173154
-0xEA
-// 0.332557
-0x2B
-// -0.227218
-0xE3
-// -0.251967
+// -0.247148
 0xE0
-// -0.347091
-0xD4
-// -0.037374
-0xFB
-// 0.292401
+// 0.012608
+0x02
+// -0.184188
+0xE8
+// -0.397120
+0xCD
+// 0.292737
 0x25
-// -0.354700
-0xD3
-// -0.005477
-0xFF
-// 0.544668
-0x46
-// 0.262989
-0x22
-// -0.023690
-0xFD
-// -0.283063
+// 0.165042
+0x15
+// -0.184831
+0xE8
+// 0.352334
+0x2D
+// -0.197430
+0xE7
+// -0.440215
+0xC8
+// 0.730979
+0x5E
+// -0.168931
+0xEA
+// -0.284822
 0xDC
-// -0.193918
+// -0.538017
+0xBB
+// 0.216999
+0x1C
+// 0.084861
+0x0B
+// 0.040200
+0x05
+// 0.008894
+0x01
+// 0.250868
+0x20
+// -0.741329
+0xA1
+// 0.509035
+0x41
+// -0.560829
+0xB8
+// -0.551232
+0xB9
+// 0.205240
+0x1A
+// 0.104891
+0x0D
+// -0.014951
+0xFE
+// -0.117553
+0xF1
+// 0.264180
+0x22
+// -0.754562
+0x9F
+// -0.249343
+0xE0
+// 0.087666
+0x0B
+// -0.197180
 0xE7
-// -0.292702
-0xDB
-// 0.346557
+// -0.210890
+0xE5
+// -0.433971
+0xC8
+// 0.225959
+0x1D
+// -0.349388
+0xD3
+// -0.632370
+0xAF
+// -0.065299
+0xF8
+// -0.364881
+0xD1
+// -0.084522
+0xF5
+// 0.039863
+0x05
+// 0.343840
 0x2C
-// -0.296799
+// -0.128365
+0xF0
+// -0.275657
+0xDD
+// 0.371014
+0x2F
+// 0.037367
+0x05
+// -0.243538
+0xE1
+// 0.011331
+0x01
+// 0.157387
+0x14
+// -0.391433
+0xCE
+// 0.135198
+0x11
+// 0.144719
+0x13
+// -0.092345
+0xF4
+// -0.297840
 0xDA
-// 0.056908
-0x07
-// -0.537311
-0xBB
-// -0.288972
-0xDB
-// -0.160006
-0xEC
-// -0.069089
-0xF7
-// 0.632783
-0x51
-// 0.097721
-0x0D
-// 0.140379
-0x12
-// 0.128600
-0x10
-// -0.082170
+// 0.283100
+0x24
+// 0.365743
+0x2F
+// -0.075729
+0xF6
+// -0.654165
+0xAC
+// 0.355507
+0x2E
+// -0.053950
+0xF9
+// -0.086130
 0xF5
-// -0.183263
-0xE9
-// 0.087751
-0x0B
-// -0.878434
-0x90
-// -0.010263
-0xFF
-// 0.385006
-0x31
-// 0.068947
+// -0.416563
+0xCB
+// 0.066606
 0x09
-// -0.354610
-0xD3
-// 0.612151
-0x4E
-// -0.341358
-0xD4
-// 0.633104
-0x51
-// -0.327233
-0xD6
-// 0.672470
-0x56
-// -0.082826
+// -0.299301
+0xDA
+// -0.089724
 0xF5
-// 0.078675
-0x0A
-// 0.027710
-0x04
-// 0.029367
+// -0.259137
+0xDF
+// 0.561349
+0x48
+// 0.113348
+0x0F
+// -0.024942
+0xFD
+// 0.452162
+0x3A
+// -0.063448
+0xF8
+// -0.062150
+0xF8
+// -0.271364
+0xDD
+// 0.135078
+0x11
+// -0.488207
+0xC2
+// -0.351589
+0xD3
+// 0.250446
+0x20
+// -0.034304
+0xFC
+// -0.307101
+0xD9
+// 0.031023
 0x04
-// 0.087025
-0x0B
-// -0.607253
-0xB2
-// 0.382469
-0x31
-// 0.300835
+// -0.236901
+0xE2
+// -0.597011
+0xB4
+// -0.040829
+0xFB
+// 0.071028
+0x09
+// -1.000000
+0x80
+// -0.036844
+0xFB
+// 0.259893
+0x21
+// 0.302588
 0x27
+// 0.032492
+0x04
+// -0.440181
+0xC8
+// 0.052180
+0x07
+// -0.041116
+0xFB
+// -0.406578
+0xCC
+// 0.252364
+0x20
+// 0.475083
+0x3D
+// -0.149191
+0xED
+// 0.353902
+0x2D
+// -0.246885
+0xE0
+// 0.077635
+0x0A
+// 0.285327
+0x25
+// 0.397953
+0x33
+// -0.062238
+0xF8
+// 0.050577
+0x06
+// -0.032614
+0xFC
+// 0.825869
+0x6A

Testing/Source/Tests/FIRF32.cpp

@@ -11,7 +11,9 @@ a double precision computation.
 */
 #define REL_ERROR (3.0e-5)
 
-__ALIGNED(8) float32_t coeffArray[32];
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+static __ALIGNED(8) float32_t coeffArray[32];
+#endif 
 
     void FIRF32::test_fir_f32()
     {

Testing/Source/Tests/FIRQ15.cpp

@@ -1,23 +1,30 @@
 #include "FIRQ15.h"
 #include "Error.h"
 
-#define SNR_THRESHOLD 60
+#define SNR_THRESHOLD 59
 
 #define ABS_ERROR_Q15 ((q15_t)2)
 
+#if defined(ARM_MATH_MVEI)
+static __ALIGNED(8) q15_t coeffArray[32];
+#endif 
+
     void FIRQ15::test_fir_q15()
     {
         
 
         const int16_t *configp = configs.ptr();
         q15_t *statep = state.ptr();
-        const q15_t *coefsp = coefs.ptr();
+        const q15_t *orgcoefsp = coefs.ptr();
+
+        const q15_t *coefsp;
         const q15_t *inputp = inputs.ptr();
         q15_t *outp = output.ptr();
 
-        int i;
+        int i,j;
         int blockSize;
         int numTaps;
+        int nb=0;
 
         /*
 
@@ -27,11 +34,26 @@
         We loop on those configs.
 
         */
-        for(i=0; i < configs.nbSamples() >> 1; i++)
+        for(i=0; i < configs.nbSamples(); i += 2)
         {
            blockSize = configp[0];
            numTaps = configp[1];
 
+#if defined(ARM_MATH_MVEI)
+           /* Copy coefficients and pad to zero 
+           */
+           memset(coeffArray,0,32);
+           for(j=0;j < numTaps; j++)
+           {
+              coeffArray[j] = orgcoefsp[j];
+           }
+   
+           coefsp = coeffArray;
+#else
+           coefsp = orgcoefsp;
+#endif
+
+
            /*
 
            The filter is initialized with the coefs, blockSize and numTaps.
@@ -55,13 +77,16 @@
 
            */
            arm_fir_q15(&this->S,inputp,outp,blockSize);
-           inputp += blockSize;
            outp += blockSize;
+
+           inputp += blockSize;
            arm_fir_q15(&this->S,inputp,outp,blockSize);
            outp += blockSize;
 
            configp += 2;
-           coefsp += numTaps;
+           orgcoefsp += numTaps;
+
+           nb += 2*blockSize;
 
         }
 

Testing/Source/Tests/FIRQ31.cpp

@@ -5,19 +5,25 @@
 
 #define ABS_ERROR_Q31 ((q31_t)2)
 
+#if defined(ARM_MATH_MVEI)
+static __ALIGNED(8) q31_t coeffArray[32];
+#endif
     void FIRQ31::test_fir_q31()
     {
         
 
         const int16_t *configp = configs.ptr();
         q31_t *statep = state.ptr();
-        const q31_t *coefsp = coefs.ptr();
+        const q31_t *orgcoefsp = coefs.ptr();
+
+        const q31_t *coefsp;
         const q31_t *inputp = inputs.ptr();
         q31_t *outp = output.ptr();
 
-        int i;
+        int i,j;
         int blockSize;
         int numTaps;
+        int nb=0;
 
         /*
 
@@ -27,11 +33,25 @@
         We loop on those configs.
 
         */
-        for(i=0; i < configs.nbSamples() >> 1; i++)
+        for(i=0; i < configs.nbSamples() ; i += 2)
         {
            blockSize = configp[0];
            numTaps = configp[1];
 
+#if defined(ARM_MATH_MVEI)
+           /* Copy coefficients and pad to zero 
+           */
+           memset(coeffArray,0,32);
+           for(j=0;j < numTaps; j++)
+           {
+              coeffArray[j] = orgcoefsp[j];
+           }
+   
+           coefsp = coeffArray;
+#else
+           coefsp = orgcoefsp;
+#endif
+
            /*
 
            The filter is initialized with the coefs, blockSize and numTaps.
@@ -54,13 +74,16 @@
 
            */
            arm_fir_q31(&this->S,inputp,outp,blockSize);
-           inputp += blockSize;
            outp += blockSize;
+
+           inputp += blockSize;
            arm_fir_q31(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
 
            configp += 2;
-           coefsp += numTaps;
-           outp += blockSize;
+           orgcoefsp += numTaps;
+
+           nb += 2*blockSize;
 
         }
 

Testing/Source/Tests/FIRQ7.cpp

@@ -5,17 +5,23 @@
 
 #define ABS_ERROR_Q7 ((q7_t)2)
 
+#if defined(ARM_MATH_MVEI)
+static __ALIGNED(8) q7_t coeffArray[32];
+#endif 
+
     void FIRQ7::test_fir_q7()
     {
         
 
         const int16_t *configp = configs.ptr();
         q7_t *statep = state.ptr();
-        const q7_t *coefsp = coefs.ptr();
+        const q7_t *orgcoefsp = coefs.ptr();
+
+        const q7_t *coefsp;
         const q7_t *inputp = inputs.ptr();
         q7_t *outp = output.ptr();
 
-        int i;
+        int i,j;
         int blockSize;
         int numTaps;
 
@@ -32,6 +38,20 @@
            blockSize = configp[0];
            numTaps = configp[1];
 
+#if defined(ARM_MATH_MVEI)
+           /* Copy coefficients and pad to zero 
+           */
+           memset(coeffArray,0,32);
+           for(j=0;j < numTaps; j++)
+           {
+              coeffArray[j] = orgcoefsp[j];
+           }
+   
+           coefsp = coeffArray;
+#else
+           coefsp = orgcoefsp;
+#endif
+
            /*
 
            The filter is initialized with the coefs, blockSize and numTaps.
@@ -54,13 +74,14 @@
 
            */
            arm_fir_q7(&this->S,inputp,outp,blockSize);
-           inputp += blockSize;
            outp += blockSize;
+
+           inputp += blockSize;
            arm_fir_q7(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
 
            configp += 2;
-           coefsp += numTaps;
-           outp += blockSize;
+           orgcoefsp += numTaps;
 
         }