landzo

【开源】线性CCD自适应性算法攻略

     */
    typedef struct
    {
        int8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
        q15_t *pState;            /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
        q15_t *pCoeffs;           /**< Points to the array of coefficients.  The array is of length 5*numStages. */
        int8_t postShift;         /**< Additional shift, in bits, applied to each output sample. */

    } arm_biquad_casd_df1_inst_q15;


    /**
     * @brief Instance structure for the Q31 Biquad cascade filter.
     */
    typedef struct
    {
        uint32_t numStages;      /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
        q31_t *pState;           /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
        q31_t *pCoeffs;          /**< Points to the array of coefficients.  The array is of length 5*numStages. */
        uint8_t postShift;       /**< Additional shift, in bits, applied to each output sample. */

    } arm_biquad_casd_df1_inst_q31;

    /**
     * @brief Instance structure for the floating-point Biquad cascade filter.
     */
    typedef struct
    {
        uint32_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
        float32_t *pState;          /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
        float32_t *pCoeffs;         /**< Points to the array of coefficients.  The array is of length 5*numStages. */


    } arm_biquad_casd_df1_inst_f32;



    /**
     * @brief Processing function for the Q15 Biquad cascade filter.
     * @param[in]  *S points to an instance of the Q15 Biquad cascade structure.
     * @param[in]  *pSrc points to the block of input data.
     * @param[out] *pDst points to the block of output data.
     * @param[in]  blockSize number of samples to process.
     * @return     none.
     */

    void arm_biquad_cascade_df1_q15(
        const arm_biquad_casd_df1_inst_q15 *S,
        q15_t *pSrc,
        q15_t *pDst,
        uint32_t blockSize);

    /**
     * @brief  Initialization function for the Q15 Biquad cascade filter.
     * @param[in,out] *S           points to an instance of the Q15 Biquad cascade structure.
     * @param[in]     numStages    number of 2nd order stages in the filter.
     * @param[in]     *pCoeffs     points to the filter coefficients.
     * @param[in]     *pState      points to the state buffer.
     * @param[in]     postShift    Shift to be applied to the output. Varies according to the coefficients format
     * @return        none
     */

    void arm_biquad_cascade_df1_init_q15(
        arm_biquad_casd_df1_inst_q15 *S,
        uint8_t numStages,
        q15_t *pCoeffs,
        q15_t *pState,
        int8_t postShift);


    /**
     * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4.
     * @param[in]  *S points to an instance of the Q15 Biquad cascade structure.
     * @param[in]  *pSrc points to the block of input data.
     * @param[out] *pDst points to the block of output data.
     * @param[in]  blockSize number of samples to process.
     * @return     none.
     */

    void arm_biquad_cascade_df1_fast_q15(
        const arm_biquad_casd_df1_inst_q15 *S,
        q15_t *pSrc,
        q15_t *pDst,
        uint32_t blockSize);


    /**
     * @brief Processing function for the Q31 Biquad cascade filter
     * @param[in]  *S         points to an instance of the Q31 Biquad cascade structure.
     * @param[in]  *pSrc      points to the block of input data.
     * @param[out] *pDst      points to the block of output data.
     * @param[in]  blockSize  number of samples to process.
     * @return     none.
     */

    void arm_biquad_cascade_df1_q31(
        const arm_biquad_casd_df1_inst_q31 *S,
        q31_t *pSrc,
        q31_t *pDst,
        uint32_t blockSize);

    /**
     * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4.
     * @param[in]  *S         points to an instance of the Q31 Biquad cascade structure.
     * @param[in]  *pSrc      points to the block of input data.
     * @param[out] *pDst      points to the block of output data.
     * @param[in]  blockSize  number of samples to process.
     * @return     none.
     */

    void arm_biquad_cascade_df1_fast_q31(
        const arm_biquad_casd_df1_inst_q31 *S,
        q31_t *pSrc,
        q31_t *pDst,
        uint32_t blockSize);

    /**
     * @brief  Initialization function for the Q31 Biquad cascade filter.
     * @param[in,out] *S           points to an instance of the Q31 Biquad cascade structure.
     * @param[in]     numStages      number of 2nd order stages in the filter.
     * @param[in]     *pCoeffs     points to the filter coefficients.
     * @param[in]     *pState      points to the state buffer.
     * @param[in]     postShift    Shift to be applied to the output. Varies according to the coefficients format
     * @return        none
     */

    void arm_biquad_cascade_df1_init_q31(
        arm_biquad_casd_df1_inst_q31 *S,
        uint8_t numStages,
        q31_t *pCoeffs,
        q31_t *pState,
        int8_t postShift);

    /**
     * @brief Processing function for the floating-point Biquad cascade filter.
     * @param[in]  *S         points to an instance of the floating-point Biquad cascade structure.
     * @param[in]  *pSrc      points to the block of input data.
     * @param[out] *pDst      points to the block of output data.
     * @param[in]  blockSize  number of samples to process.
     * @return     none.
     */

    void arm_biquad_cascade_df1_f32(
        const arm_biquad_casd_df1_inst_f32 *S,
        float32_t *pSrc,
        float32_t *pDst,
        uint32_t blockSize);

    /**
     * @brief  Initialization function for the floating-point Biquad cascade filter.
     * @param[in,out] *S           points to an instance of the floating-point Biquad cascade structure.
     * @param[in]     numStages    number of 2nd order stages in the filter.
     * @param[in]     *pCoeffs     points to the filter coefficients.
     * @param[in]     *pState      points to the state buffer.
     * @return        none
     */

    void arm_biquad_cascade_df1_init_f32(
        arm_biquad_casd_df1_inst_f32 *S,
        uint8_t numStages,
        float32_t *pCoeffs,
        float32_t *pState);


    /**
     * @brief Instance structure for the floating-point matrix structure.
     */

    typedef struct
    {
        uint16_t numRows;     /**< number of rows of the matrix.     */
        uint16_t numCols;     /**< number of columns of the matrix.  */
        float32_t *pData;     /**< points to the data of the matrix. */
    } arm_matrix_instance_f32;

    /**
     * @brief Instance structure for the Q15 matrix structure.
     */

    typedef struct
    {
        uint16_t numRows;     /**< number of rows of the matrix.     */
        uint16_t numCols;     /**< number of columns of the matrix.  */
        q15_t *pData;         /**< points to the data of the matrix. */

    } arm_matrix_instance_q15;

    /**
     * @brief Instance structure for the Q31 matrix structure.
     */

    typedef struct
    {
        uint16_t numRows;     /**< number of rows of the matrix.     */
        uint16_t numCols;     /**< number of columns of the matrix.  */
        q31_t *pData;         /**< points to the data of the matrix. */

    } arm_matrix_instance_q31;



    /**
     * @brief Floating-point matrix addition.
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_add_f32(
        const arm_matrix_instance_f32 *pSrcA,
        const arm_matrix_instance_f32 *pSrcB,
        arm_matrix_instance_f32 *pDst);

    /**
     * @brief Q15 matrix addition.
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_add_q15(
        const arm_matrix_instance_q15 *pSrcA,
        const arm_matrix_instance_q15 *pSrcB,
        arm_matrix_instance_q15 *pDst);

    /**
     * @brief Q31 matrix addition.
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_add_q31(
        const arm_matrix_instance_q31 *pSrcA,
        const arm_matrix_instance_q31 *pSrcB,
        arm_matrix_instance_q31 *pDst);


    /**
     * @brief Floating-point matrix transpose.
     * @param[in]  *pSrc points to the input matrix
     * @param[out] *pDst points to the output matrix
     * @return 	The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
     * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_trans_f32(
        const arm_matrix_instance_f32 *pSrc,
        arm_matrix_instance_f32 *pDst);


    /**
     * @brief Q15 matrix transpose.
     * @param[in]  *pSrc points to the input matrix
     * @param[out] *pDst points to the output matrix
     * @return 	The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
     * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_trans_q15(
        const arm_matrix_instance_q15 *pSrc,
        arm_matrix_instance_q15 *pDst);

    /**
     * @brief Q31 matrix transpose.
     * @param[in]  *pSrc points to the input matrix
     * @param[out] *pDst points to the output matrix
     * @return 	The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
     * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_trans_q31(
        const arm_matrix_instance_q31 *pSrc,
        arm_matrix_instance_q31 *pDst);


    /**
     * @brief Floating-point matrix multiplication
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_mult_f32(
        const arm_matrix_instance_f32 *pSrcA,
        const arm_matrix_instance_f32 *pSrcB,
        arm_matrix_instance_f32 *pDst);

    /**
     * @brief Q15 matrix multiplication
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_mult_q15(
        const arm_matrix_instance_q15 *pSrcA,
        const arm_matrix_instance_q15 *pSrcB,
        arm_matrix_instance_q15 *pDst,
        q15_t *pState);

    /**
     * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
     * @param[in]       *pSrcA  points to the first input matrix structure
     * @param[in]       *pSrcB  points to the second input matrix structure
     * @param[out]      *pDst   points to output matrix structure
     * @param[in]		  *pState points to the array for storing intermediate results
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_mult_fast_q15(
        const arm_matrix_instance_q15 *pSrcA,
        const arm_matrix_instance_q15 *pSrcB,
        arm_matrix_instance_q15 *pDst,
        q15_t *pState);

    /**
     * @brief Q31 matrix multiplication
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_mult_q31(
        const arm_matrix_instance_q31 *pSrcA,
        const arm_matrix_instance_q31 *pSrcB,
        arm_matrix_instance_q31 *pDst);

    /**
     * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_mult_fast_q31(
        const arm_matrix_instance_q31 *pSrcA,
        const arm_matrix_instance_q31 *pSrcB,
        arm_matrix_instance_q31 *pDst);


    /**
     * @brief Floating-point matrix subtraction
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_sub_f32(
        const arm_matrix_instance_f32 *pSrcA,
        const arm_matrix_instance_f32 *pSrcB,
        arm_matrix_instance_f32 *pDst);

    /**
     * @brief Q15 matrix subtraction
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either
     * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
     */

    arm_status arm_mat_sub_q15(
        const arm_matrix_instance_q15 *pSrcA,
        const arm_matrix_instance_q15 *pSrcB,
        arm_matrix_instance_q15 *pDst);

    /**
     * @brief Q31 matrix subtraction
     * @param[in]       *pSrcA points to the first input matrix structure
     * @param[in]       *pSrcB points to the second input matrix structure
     * @param[out]      *pDst points to output matrix structure
     * @return     The function returns either