/** \brief Test case: TC_CoreSimd_SatAddSub \details - Check Saturating addition and subtraction: __QADD __QSUB */ void TC_CoreSimd_SatAddSub (void) { #if ((defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \ (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1)) ) volatile int32_t op1_s32, op2_s32; volatile int32_t res_s32; /* --- __QADD Test ---------------------------------------------- */ op1_s32 = (int32_t)0x80000003; op2_s32 = (int32_t)0x00000004; res_s32 = __QADD(op1_s32, op2_s32); ASSERT_TRUE(res_s32 == (int32_t)0x80000007); op1_s32 = (int32_t)0x80000000; op2_s32 = (int32_t)0x80000002; res_s32 = __QADD(op1_s32, op2_s32); ASSERT_TRUE(res_s32 == (int32_t)0x80000000); /* --- __QSUB Test ---------------------------------------------- */ op1_s32 = (int32_t)0x80000003; op2_s32 = (int32_t)0x00000004; res_s32 = __QSUB(op1_s32, op2_s32); ASSERT_TRUE(res_s32 == (int32_t)0x80000000); op1_s32 = (int32_t)0x80000003; op2_s32 = (int32_t)0x00000002; res_s32 = __QSUB(op1_s32, op2_s32); ASSERT_TRUE(res_s32 == (int32_t)0x80000001); #endif }
void arm_sub_q31( q31_t * pSrcA, q31_t * pSrcB, q31_t * pDst, uint32_t blockSize) { uint32_t blkCnt; /* loop counter */ #ifndef ARM_MATH_CM0_FAMILY /* Run the below code for Cortex-M4 and Cortex-M3 */ q31_t inA1, inA2, inA3, inA4; q31_t inB1, inB2, inB3, inB4; /*loop Unrolling */ blkCnt = blockSize >> 2u; /* First part of the processing with loop unrolling. Compute 4 outputs at a time. ** a second loop below computes the remaining 1 to 3 samples. */ while(blkCnt > 0u) { /* C = A - B */ /* Subtract and then store the results in the destination buffer. */ inA1 = *pSrcA++; inA2 = *pSrcA++; inB1 = *pSrcB++; inB2 = *pSrcB++; inA3 = *pSrcA++; inA4 = *pSrcA++; inB3 = *pSrcB++; inB4 = *pSrcB++; *pDst++ = __QSUB(inA1, inB1); *pDst++ = __QSUB(inA2, inB2); *pDst++ = __QSUB(inA3, inB3); *pDst++ = __QSUB(inA4, inB4); /* Decrement the loop counter */ blkCnt--; } /* If the blockSize is not a multiple of 4, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = blockSize % 0x4u; while(blkCnt > 0u) { /* C = A - B */ /* Subtract and then store the result in the destination buffer. */ *pDst++ = __QSUB(*pSrcA++, *pSrcB++); /* Decrement the loop counter */ blkCnt--; } #else /* Run the below code for Cortex-M0 */ /* Initialize blkCnt with number of samples */ blkCnt = blockSize; while(blkCnt > 0u) { /* C = A - B */ /* Subtract and then store the result in the destination buffer. */ *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ - *pSrcB++); /* Decrement the loop counter */ blkCnt--; } #endif /* #ifndef ARM_MATH_CM0_FAMILY */ }
arm_status arm_mat_sub_q31( const arm_matrix_instance_q31 * pSrcA, const arm_matrix_instance_q31 * pSrcB, arm_matrix_instance_q31 * pDst) { q31_t *pIn1 = pSrcA->pData; /* input data matrix pointer A */ q31_t *pIn2 = pSrcB->pData; /* input data matrix pointer B */ q31_t *pOut = pDst->pData; /* output data matrix pointer */ q31_t inA1, inA2, inB1, inB2; /* temporary variables */ q31_t out1, out2; /* temporary variables */ uint32_t numSamples; /* total number of elements in the matrix */ uint32_t blkCnt; /* loop counters */ arm_status status; /* status of matrix subtraction */ #ifdef ARM_MATH_MATRIX_CHECK /* Check for matrix mismatch condition */ if((pSrcA->numRows != pSrcB->numRows) || (pSrcA->numCols != pSrcB->numCols) || (pSrcA->numRows != pDst->numRows) || (pSrcA->numCols != pDst->numCols)) { /* Set status as ARM_MATH_SIZE_MISMATCH */ status = ARM_MATH_SIZE_MISMATCH; } else #endif { /* Total number of samples in the input matrix */ numSamples = (uint32_t) pSrcA->numRows * pSrcA->numCols; /* Loop Unrolling */ blkCnt = numSamples >> 3u; /* First part of the processing with loop unrolling. Compute 8 outputs at a time. ** a second loop below computes the remaining 1 to 7 samples. */ while(blkCnt > 0u) { /* C(m,n) = A(m,n) - B(m,n) */ /* Subtract, saturate and then store the results in the destination buffer. */ /* Read values from source A */ inA1 = pIn1[0]; /* Read values from source B */ inB1 = pIn2[0]; /* Read values from source A */ inA2 = pIn1[1]; /* Subtract and saturate */ out1 = __QSUB(inA1, inB1); /* Read values from source B */ inB2 = pIn2[1]; /* Read values from source A */ inA1 = pIn1[2]; /* Subtract and saturate */ out2 = __QSUB(inA2, inB2); /* Read values from source B */ inB1 = pIn2[2]; /* Store result in destination */ pOut[0] = out1; pOut[1] = out2; /* Read values from source A */ inA2 = pIn1[3]; /* Read values from source B */ inB2 = pIn2[3]; /* Subtract and saturate */ out1 = __QSUB(inA1, inB1); /* Read values from source A */ inA1 = pIn1[4]; /* Subtract and saturate */ out2 = __QSUB(inA2, inB2); /* Read values from source B */ inB1 = pIn2[4]; /* Store result in destination */ pOut[2] = out1; /* Read values from source A */ inA2 = pIn1[5]; /* Subtract and saturate */ out1 = __QSUB(inA1, inB1); /* Read values from source B */ inB2 = pIn2[5]; /* Store result in destination */ pOut[3] = out2; /* Read values from source A */ inA1 = pIn1[6]; /* Subtract and saturate */ out2 = __QSUB(inA2, inB2); /* Read values from source A */ inA2 = pIn1[7]; /* Read values from source B */ inB1 = pIn2[6]; inB2 = pIn2[7]; /* Store result in destination */ pOut[4] = out1; /* Subtract and saturate */ out1 = __QSUB(inA1, inB1); /* Store result in destination */ pOut[5] = out2; /* Subtract and saturate */ out2 = __QSUB(inA2, inB2); /* Store result in destination */ pOut[6] = out1; /* Increment Soruce A pointer */ pIn1 += 8u; pOut[7] = out2; /* Increment Soruce B pointer */ pIn2 += 8u; /* Increment Destination pointer */ pOut += 8u; /* Decrement the loop counter */ blkCnt--; } /* If the numSamples is not a multiple of 8, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = numSamples % 0x8u; while(blkCnt > 0u) { /* C(m,n) = A(m,n) - B(m,n) */ /* Subtract, saturate and then store the results in the destination buffer. */ inA1 = *pIn1++; inB1 = *pIn2++; inA1 = __QSUB(inA1, inB1); *pOut++ = inA1; /* Decrement the loop counter */ blkCnt--; } /* Set status as ARM_MATH_SUCCESS */ status = ARM_MATH_SUCCESS; } /* Return to application */ return (status); }
void arm_abs_q31( q31_t * pSrc, q31_t * pDst, uint32_t blockSize) { uint32_t blkCnt; /* loop counter */ q31_t in; /* Input value */ #ifndef ARM_MATH_CM0_FAMILY /* Run the below code for Cortex-M4 and Cortex-M3 */ q31_t in1, in2, in3, in4; /*loop Unrolling */ blkCnt = blockSize >> 2u; /* First part of the processing with loop unrolling. Compute 4 outputs at a time. ** a second loop below computes the remaining 1 to 3 samples. */ while(blkCnt > 0u) { /* C = |A| */ /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */ in1 = *pSrc++; in2 = *pSrc++; in3 = *pSrc++; in4 = *pSrc++; *pDst++ = (in1 > 0) ? in1 : (q31_t)__QSUB(0, in1); *pDst++ = (in2 > 0) ? in2 : (q31_t)__QSUB(0, in2); *pDst++ = (in3 > 0) ? in3 : (q31_t)__QSUB(0, in3); *pDst++ = (in4 > 0) ? in4 : (q31_t)__QSUB(0, in4); /* Decrement the loop counter */ blkCnt--; } /* If the blockSize is not a multiple of 4, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = blockSize % 0x4u; #else /* Run the below code for Cortex-M0 */ /* Initialize blkCnt with number of samples */ blkCnt = blockSize; #endif /* #ifndef ARM_MATH_CM0_FAMILY */ while(blkCnt > 0u) { /* C = |A| */ /* Calculate absolute value of the input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */ in = *pSrc++; *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in); /* Decrement the loop counter */ blkCnt--; } }
void arm_cmplx_conj_q31( q31_t * pSrc, q31_t * pDst, uint32_t numSamples) { uint32_t blkCnt; /* loop counter */ q31_t in; /* Input value */ #ifndef ARM_MATH_CM0_FAMILY /* Run the below code for Cortex-M4 and Cortex-M3 */ q31_t inR1, inR2, inR3, inR4; /* Temporary real variables */ q31_t inI1, inI2, inI3, inI4; /* Temporary imaginary variables */ /*loop Unrolling */ blkCnt = numSamples >> 2u; /* First part of the processing with loop unrolling. Compute 4 outputs at a time. ** a second loop below computes the remaining 1 to 3 samples. */ while(blkCnt > 0u) { /* C[0]+jC[1] = A[0]+ j (-1) A[1] */ /* Calculate Complex Conjugate and then store the results in the destination buffer. */ /* Saturated to 0x7fffffff if the input is -1(0x80000000) */ /* read real input sample */ inR1 = pSrc[0]; /* store real input sample */ pDst[0] = inR1; /* read imaginary input sample */ inI1 = pSrc[1]; /* read real input sample */ inR2 = pSrc[2]; /* store real input sample */ pDst[2] = inR2; /* read imaginary input sample */ inI2 = pSrc[3]; /* negate imaginary input sample */ inI1 = __QSUB(0, inI1); /* read real input sample */ inR3 = pSrc[4]; /* store real input sample */ pDst[4] = inR3; /* read imaginary input sample */ inI3 = pSrc[5]; /* negate imaginary input sample */ inI2 = __QSUB(0, inI2); /* read real input sample */ inR4 = pSrc[6]; /* store real input sample */ pDst[6] = inR4; /* negate imaginary input sample */ inI3 = __QSUB(0, inI3); /* store imaginary input sample */ inI4 = pSrc[7]; /* store imaginary input samples */ pDst[1] = inI1; /* negate imaginary input sample */ inI4 = __QSUB(0, inI4); /* store imaginary input samples */ pDst[3] = inI2; /* increment source pointer by 8 to proecess next samples */ pSrc += 8u; /* store imaginary input samples */ pDst[5] = inI3; pDst[7] = inI4; /* increment destination pointer by 8 to process next samples */ pDst += 8u; /* Decrement the loop counter */ blkCnt--; } /* If the numSamples is not a multiple of 4, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = numSamples % 0x4u; #else /* Run the below code for Cortex-M0 */ blkCnt = numSamples; #endif /* #ifndef ARM_MATH_CM0_FAMILY */ while(blkCnt > 0u) { /* C[0]+jC[1] = A[0]+ j (-1) A[1] */ /* Calculate Complex Conjugate and then store the results in the destination buffer. */ /* Saturated to 0x7fffffff if the input is -1(0x80000000) */ *pDst++ = *pSrc++; in = *pSrc++; *pDst++ = (in == INT32_MIN) ? INT32_MAX : -in; /* Decrement the loop counter */ blkCnt--; } }
// software distributed under the License is distributed on an // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY // KIND, either express or implied. See the License for the // specific language governing permissions and limitations // under the License #define OP_NAME isub #include <ngl_opcode_begin.c> #ifdef OPCODE_BODY #ifdef NGL_ARM { ngl_val right = ngl_stack_pop(&stack); ngl_val left = ngl_stack_pop(&stack); ngl_stack_push(&stack, ngl_val_uint(__QSUB(left.uinteger, right.uinteger))); } #else { ngl_val right = ngl_stack_pop(&stack); ngl_val left = ngl_stack_pop(&stack); int64_t sum = (int64_t)(left.integer) - (int64_t)(right.integer); if (sum > INT_MAX) { sum = INT_MAX; } if (sum < INT_MIN) { sum = INT_MIN; } ngl_stack_push(&stack, ngl_val_int(sum)); } #endif
void arm_negate_q31( q31_t * pSrc, q31_t * pDst, uint32_t blockSize) { q31_t in1, in2, in3, in4; /* Temporary variables */ uint32_t blkCnt; /* loop counter */ /*loop Unrolling */ blkCnt = blockSize >> 3u; /* First part of the processing with loop unrolling. Compute 8 outputs at a time. ** a second loop below computes the remaining 1 to 7 samples. */ while(blkCnt > 0u) { /* C = -A */ /* Negate and then store the results in the destination buffer. */ /* read samples from source */ in1 = *pSrc; in2 = *(pSrc + 1); /* negate input */ in1 = __QSUB(0, in1); /* read samples from source */ in3 = *(pSrc + 2); /* negate input */ in2 = __QSUB(0, in2); /* read samples from source */ in4 = *(pSrc + 3); /* negate input */ in3 = __QSUB(0, in3); /* store result to destination */ *pDst = in1; /* negate input */ in4 = __QSUB(0, in4); /* store result to destination */ *(pDst + 1) = in2; *(pDst + 2) = in3; *(pDst + 3) = in4; /* read samples from source */ in1 = *(pSrc + 4); in2 = *(pSrc + 5); /* negate input */ in1 = __QSUB(0, in1); /* read samples from source */ in3 = *(pSrc + 6); /* negate input */ in2 = __QSUB(0, in2); /* read samples from source */ in4 = *(pSrc + 7); /* negate input */ in3 = __QSUB(0, in3); /* store result to destination */ *(pDst + 4) = in1; /* negate input */ in4 = __QSUB(0, in4); /* store result to destination */ *(pDst + 5) = in2; /* increment source by 8 to process next samples */ pSrc += 8u; /* store result to destination */ *(pDst + 6) = in3; *(pDst + 7) = in4; /* increment destination by 8 */ pDst += 8u; /* Decrement the loop counter */ blkCnt--; } /* If the blockSize is not a multiple of 8, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = blockSize % 0x8u; while(blkCnt > 0u) { /* C = -A */ /* Negate and then store the result in the destination buffer. */ in1 = *pSrc++; *pDst++ = __QSUB(0, in1); /* Decrement the loop counter */ blkCnt--; } }
void arm_negate_q31( q31_t * pSrc, q31_t * pDst, uint32_t blockSize) { q31_t in; /* Temporary variable */ uint32_t blkCnt; /* loop counter */ #ifndef ARM_MATH_CM0 /* Run the below code for Cortex-M4 and Cortex-M3 */ q31_t in1, in2, in3, in4; /*loop Unrolling */ blkCnt = blockSize >> 2u; /* First part of the processing with loop unrolling. Compute 4 outputs at a time. ** a second loop below computes the remaining 1 to 3 samples. */ while(blkCnt > 0u) { /* C = -A */ /* Negate and then store the results in the destination buffer. */ in1 = *pSrc++; in2 = *pSrc++; in3 = *pSrc++; in4 = *pSrc++; *pDst++ = __QSUB(0, in1); *pDst++ = __QSUB(0, in2); *pDst++ = __QSUB(0, in3); *pDst++ = __QSUB(0, in4); /* Decrement the loop counter */ blkCnt--; } /* If the blockSize is not a multiple of 4, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = blockSize % 0x4u; #else /* Run the below code for Cortex-M0 */ /* Initialize blkCnt with number of samples */ blkCnt = blockSize; #endif /* #ifndef ARM_MATH_CM0 */ while(blkCnt > 0u) { /* C = -A */ /* Negate and then store the result in the destination buffer. */ in = *pSrc++; *pDst++ = (in == 0x80000000) ? 0x7fffffff : -in; /* Decrement the loop counter */ blkCnt--; } }
void arm_abs_q15( q15_t * pSrc, q15_t * pDst, uint32_t blockSize) { uint32_t blkCnt; /* loop counter */ q31_t in1, in2, in3, in4; /* temporary input variables */ q31_t out1, out2, out3, out4; /* temporary output variabels */ /*loop Unrolling */ blkCnt = blockSize >> 3u; /* First part of the processing with loop unrolling. Compute 8 outputs at a time. ** a second loop below computes the remaining 1 to 7 samples. */ while(blkCnt > 0u) { /* C = |A| */ /* Read inputs */ in1 = (q31_t)*pSrc; in2 = (q31_t)*(pSrc + 1); in3 = (q31_t)*(pSrc + 2); /* find absolute value */ out1 = (in1 > 0) ? in1 : __QSUB(0, in1); /* read input */ in4 = (q31_t)*(pSrc + 3); /* find absolute value */ out2 = (in2 > 0) ? in2 : __QSUB(0, in2); /* store result to destination */ *pDst = (q15_t)out1; /* find absolute value */ out3 = (in3 > 0) ? in3 : __QSUB(0, in3); /* read input */ in1 = (q31_t)*(pSrc + 4); /* find absolute value */ out4 = (in4 > 0) ? in4 : __QSUB(0, in4); /* store result to destination */ *(pDst + 1) = (q15_t)out2; /* read input */ in2 = (q31_t)*(pSrc + 5); /* find absolute value */ out1 = (in1 > 0) ? in1 : __QSUB(0, in1); /* store result to destination */ *(pDst + 2) = (q15_t)out3; /* find absolute value */ out2 = (in2 > 0) ? in2 : __QSUB(0, in2); /* read input */ in3 = (q31_t)*(pSrc + 6); /* store result to destination */ *(pDst + 3) = (q15_t)out4; /* read input */ in4 = (q31_t)*(pSrc + 7); /* find absolute value */ out3 = (in3 > 0) ? in3 : __QSUB(0, in3); /* store result to destination */ *(pDst + 4) = (q15_t)out1; /* find absolute value */ out4 = (in4 > 0) ? in4 : __QSUB(0, in4); /* store result to destination */ *(pDst + 5) = (q15_t)out2; *(pDst + 6) = (q15_t)out3; /* increment source pointer by 8 */ pSrc += 8u; /* store result to destination */ *(pDst + 7) = (q15_t)out4; /* increment destination pointer by 8 */ pDst += 8u; /* Decrement the loop counter */ blkCnt--; } /* If the blockSize is not a multiple of 8, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = blockSize % 0x8u; while(blkCnt > 0u) { /* C = |A| */ /* Read the input */ in1 = *pSrc++; /* Calculate absolute value of input and then store the result in the destination buffer. */ *pDst++ = (in1 > 0) ? in1 : __QSUB16(0, in1); /* Decrement the loop counter */ blkCnt--; } }
arm_status arm_mat_sub_q31( const arm_matrix_instance_q31 * pSrcA, const arm_matrix_instance_q31 * pSrcB, arm_matrix_instance_q31 * pDst) { q31_t *pIn1 = pSrcA->pData; /** input data matrix pointer A */ q31_t *pIn2 = pSrcB->pData; /** input data matrix pointer B */ q31_t *pOut = pDst->pData; /** output data matrix pointer */ q31_t inA1, inB1; /** temporary variables */ #ifndef ARM_MATH_CM0_FAMILY q31_t inA2, inB2; /** temporary variables */ q31_t out1, out2; /** temporary variables */ #endif // #ifndef ARM_MATH_CM0_FAMILY uint32_t numSamples; /** total number of elements in the matrix */ uint32_t blkCnt; /** loop counters */ arm_status status; /** status of matrix subtraction */ #ifdef ARM_MATH_MATRIX_CHECK /** Check for matrix mismatch condition */ if((pSrcA->numRows != pSrcB->numRows) || (pSrcA->numCols != pSrcB->numCols) || (pSrcA->numRows != pDst->numRows) || (pSrcA->numCols != pDst->numCols)) { /** Set status as ARM_MATH_SIZE_MISMATCH */ status = ARM_MATH_SIZE_MISMATCH; } else #endif { /** Total number of samples in the input matrix */ numSamples = (uint32_t) pSrcA->numRows * pSrcA->numCols; #ifndef ARM_MATH_CM0_FAMILY /** Run the below code for Cortex-M4 and Cortex-M3 */ /** Loop Unrolling */ blkCnt = numSamples >> 2u; /** First part of the processing with loop unrolling. Compute 4 outputs at a time. ** a second loop below computes the remaining 1 to 3 samples. */ while(blkCnt > 0u) { /** C(m,n) = A(m,n) - B(m,n) */ /** Subtract, saturate and then store the results in the destination buffer. */ /** Read values from source A */ inA1 = pIn1[0]; /** Read values from source B */ inB1 = pIn2[0]; /** Read values from source A */ inA2 = pIn1[1]; /** Subtract and saturate */ out1 = __QSUB(inA1, inB1); /** Read values from source B */ inB2 = pIn2[1]; /** Read values from source A */ inA1 = pIn1[2]; /** Subtract and saturate */ out2 = __QSUB(inA2, inB2); /** Read values from source B */ inB1 = pIn2[2]; /** Store result in destination */ pOut[0] = out1; pOut[1] = out2; /** Read values from source A */ inA2 = pIn1[3]; /** Read values from source B */ inB2 = pIn2[3]; /** Subtract and saturate */ out1 = __QSUB(inA1, inB1); /** Subtract and saturate */ out2 = __QSUB(inA2, inB2); /** Store result in destination */ pOut[2] = out1; pOut[3] = out2; /** update pointers to process next samples */ pIn1 += 4u; pIn2 += 4u; pOut += 4u; /** Decrement the loop counter */ blkCnt--; } /** If the numSamples is not a multiple of 4, compute any remaining output samples here. ** No loop unrolling is used. */ blkCnt = numSamples % 0x4u; #else /** Run the below code for Cortex-M0 */ /** Initialize blkCnt with number of samples */ blkCnt = numSamples; #endif /* #ifndef ARM_MATH_CM0_FAMILY */ while(blkCnt > 0u) { /** C(m,n) = A(m,n) - B(m,n) */ /** Subtract, saturate and then store the results in the destination buffer. */ inA1 = *pIn1++; inB1 = *pIn2++; inA1 = __QSUB(inA1, inB1); *pOut++ = inA1; /** Decrement the loop counter */ blkCnt--; } /** Set status as ARM_MATH_SUCCESS */ status = ARM_MATH_SUCCESS; } /** Return to application */ return (status); }
void arm_abs_q7( const q7_t * pSrc, q7_t * pDst, uint32_t blockSize) { uint32_t blkCnt; /* Loop counter */ q7_t in; /* Temporary input variable */ #if defined (ARM_MATH_LOOPUNROLL) /* Loop unrolling: Compute 4 outputs at a time */ blkCnt = blockSize >> 2U; while (blkCnt > 0U) { /* C = |A| */ /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer. */ in = *pSrc++; #if defined (ARM_MATH_DSP) *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in); #else *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in); #endif in = *pSrc++; #if defined (ARM_MATH_DSP) *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in); #else *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in); #endif in = *pSrc++; #if defined (ARM_MATH_DSP) *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in); #else *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in); #endif in = *pSrc++; #if defined (ARM_MATH_DSP) *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in); #else *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in); #endif /* Decrement loop counter */ blkCnt--; } /* Loop unrolling: Compute remaining outputs */ blkCnt = blockSize % 0x4U; #else /* Initialize blkCnt with number of samples */ blkCnt = blockSize; #endif /* #if defined (ARM_MATH_LOOPUNROLL) */ while (blkCnt > 0U) { /* C = |A| */ /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer. */ in = *pSrc++; #if defined (ARM_MATH_DSP) *pDst++ = (in > 0) ? in : (q7_t) __QSUB(0, in); #else *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in); #endif /* Decrement loop counter */ blkCnt--; } }