/**
 * File: omxSP.h
 * Brief: OpenMAX DL v1.0.2 - Signal Processing library
 *
 * Copyright 2005-2008 The Khronos Group Inc. All Rights Reserved.
 *
 * These materials are protected by copyright laws and contain material
 * proprietary to the Khronos Group, Inc.  You may use these materials
 * for implementing Khronos specifications, without altering or removing
 * any trademark, copyright or other notice from the specification.
 *
 * Khronos Group makes no, and expressly disclaims any, representations
 * or warranties, express or implied, regarding these materials, including,
 * without limitation, any implied warranties of merchantability or fitness
 * for a particular purpose or non-infringement of any intellectual property.
 * Khronos Group makes no, and expressly disclaims any, warranties, express
 * or implied, regarding the correctness, accuracy, completeness, timeliness,
 * and reliability of these materials.
 *
 * Under no circumstances will the Khronos Group, or any of its Promoters,
 * Contributors or Members or their respective partners, officers, directors,
 * employees, agents or representatives be liable for any damages, whether
 * direct, indirect, special or consequential damages for lost revenues,
 * lost profits, or otherwise, arising from or in connection with these
 * materials.
 *
 * Khronos and OpenMAX are trademarks of the Khronos Group Inc.
 *
 */

/* *****************************************************************************************/

#ifndef _OMXSP_H_
#define _OMXSP_H_

#include "dl/api/omxtypes.h"

#ifdef __cplusplus
extern "C" {
#endif


/* 2.1 Vendor-Specific FFT Data Structures */
 typedef void OMXFFTSpec_C_SC16;
 typedef void OMXFFTSpec_C_SC32;
 typedef void OMXFFTSpec_R_S16S32;
 typedef void OMXFFTSpec_R_S16;
 typedef void OMXFFTSpec_R_S32;
 typedef void OMXFFTSpec_R_F32;
 typedef void OMXFFTSpec_C_FC32;

/**
 * Function:  omxSP_Copy_S16   (2.2.1.1.1)
 *
 * Description:
 * Copies the len elements of the vector pointed to by pSrcinto the len
 * elements of the vector pointed to by pDst. That is:
 *     pDst[i] = pSrc[i], for (i=0, 1, ..., len-1)
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the source vector
 *   len - number of elements contained in the source and destination vectors
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination vector
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments detected; returned if one or more of
 *              the following is true:
 *    -   pSrc or pDst is NULL
 *    -   len < 0
 *
 */
OMXResult omxSP_Copy_S16 (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_INT len
);


/**
 * Function:  omxSP_DotProd_S16   (2.2.2.1.1)
 *
 * Description:
 * Calculates the dot product of the two input vectors.  This function does
 * not perform scaling. The internal accumulator width must be at least 32
 * bits.  If any of the partially accumulated values exceeds the range of a
 * signed 32-bit integer then the result is undefined.
 *
 * Input Arguments:
 *
 *   pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
 *            boundary.
 *   pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
 *            boundary.
 *   len - length of the vectors in pSrc1 and pSrc2
 *
 * Output Arguments:
 *
 * Return Value:
 *
 *    The dot product result  Note: this function returns the actual result
 *              rather than the standard OMXError.
 *
 */
OMX_S32 omxSP_DotProd_S16 (
    const OMX_S16 *pSrc1,
    const OMX_S16 *pSrc2,
    OMX_INT len
);


/**
 * Function:  omxSP_DotProd_S16_Sfs   (2.2.2.1.2)
 *
 * Description:
 * Calculates the dot product of the two input signals with output scaling
 * and saturation, i.e., the result is multiplied by two to the power of the
 * negative (-)scalefactor (scaled) prior to return.  The result is saturated
 * with rounding if the scaling operation produces a value outside the range
 * of a signed 32-bit integer. Rounding behavior is defined in section 1.6.7
 * Integer Scaling and Rounding Conventions. The internal accumulator width
 * must be at least 32 bits. The result is undefined if any of the partially
 * accumulated values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
 *            boundary.
 *   pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
 *            boundary.
 *   len - length of the vectors in pSrc1 and pSrc2
 *   scaleFactor - integer scalefactor
 *
 * Output Arguments:
 *
 * Return Value:
 *
 *    The dot product result  Note: This function returns the actual result
 *              rather than the standard OMXError.
 *
 */
OMX_S32 omxSP_DotProd_S16_Sfs (
    const OMX_S16 *pSrc1,
    const OMX_S16 *pSrc2,
    OMX_INT len,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_BlockExp_S16   (2.2.2.2.2)
 *
 * Description:
 * Block exponent calculation for 16-bit and 32-bit signals (count leading
 * sign bits). These functions compute the number of extra sign bits of all
 * values in the 16-bit and 32-bit input vector pSrc and return the minimum
 * sign bit count. This is also the maximum shift value that could be used in
 * scaling the block of data.  The functions BlockExp_S16 and
 * BlockExp_S32 return the values 15 and 31, respectively, for input vectors in
 * which all entries are equal to zero.
 *
 * Note: These functions differ from other DL functions by not returning the
 *       standard OMXError but the actual result.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the input vector
 *   len - number of elements contained in the input and output
 *         vectors (0 < len < 65536)
 *
 * Output Arguments:
 *
 *   none
 *
 * Return Value:
 *
 *    Maximum exponent that may be used in scaling
 *
 */
OMX_INT omxSP_BlockExp_S16 (
    const OMX_S16 *pSrc,
    OMX_INT len
);


/**
 * Function:  omxSP_BlockExp_S32   (2.2.2.2.2)
 *
 * Description:
 * Block exponent calculation for 16-bit and 32-bit signals (count leading
 * sign bits). These functions compute the number of extra sign bits of all
 * values in the 16-bit and 32-bit input vector pSrc and return the minimum
 * sign bit count. This is also the maximum shift value that could be used in
 * scaling the block of data.  The functions BlockExp_S16 and
 * BlockExp_S32 return the values 15 and 31, respectively, for input vectors in
 * which all entries are equal to zero.
 *
 * Note: These functions differ from other DL functions by not returning the
 *       standard OMXError but the actual result.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the input vector
 *   len - number of elements contained in the input and output
 *         vectors (0 < len < 65536)
 *
 * Output Arguments:
 *
 *   none
 *
 * Return Value:
 *
 *    Maximum exponent that may be used in scaling
 *
 */
OMX_INT omxSP_BlockExp_S32 (
    const OMX_S32 *pSrc,
    OMX_INT len
);


/**
 * Function:  omxSP_FIR_Direct_S16   (2.2.3.1.1)
 *
 * Description:
 * Block FIR filtering for 16-bit data type.  This function applies the
 * FIR filter defined by the coefficient vector pTapsQ15 to a vector of
 * input data.  The result is saturated with rounding if the operation
 * produces a value outside the range of a signed 16-bit integer.
 * Rounding behavior is defined in:
 *     section 1.6.7 "Integer Scaling and Rounding Conventions".
 * The internal accumulator width must be at least 32 bits.  The result
 * is undefined if any of the partially accumulated values exceeds the
 * range of a signed 32-bit integer.
 *
 *
 * Input Arguments:
 *
 *   pSrc   - pointer to the vector of input samples to which the
 *            filter is applied
 *   sampLen - the number of samples contained in the input and output
 *            vectors
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                     0 = k <tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *
 * Output Arguments:
 *
 *   pDst   - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   One or more of the following pointers is NULL:
 *          -  pSrc,
 *          -  pDst,
 *          -  pSrcDst,
 *          -  pTapsQ15,
 *          -  pDelayLine, or
 *          -  pDelayLineIndex
 *    -   samplen < 0
 *    -   tapslen < 1
 *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 *
 */
OMXResult omxSP_FIR_Direct_S16 (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_INT sampLen,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex
);


/**
 * Function:  omxSP_FIR_Direct_S16_I   (2.2.3.1.1)
 *
 * Description:
 * Block FIR filtering for 16-bit data type.  This function applies the
 * FIR filter defined by the coefficient vector pTapsQ15 to a vector of
 * input data.  The result is saturated with rounding if the operation
 * produces a value outside the range of a signed 16-bit integer.
 * Rounding behavior is defined in:
 *     section 1.6.7 "Integer Scaling and Rounding Conventions".
 * The internal accumulator width must be at least 32 bits.  The result
 * is undefined if any of the partially accumulated values exceeds the
 * range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the vector of input samples to which the
 *            filter is applied
 *   sampLen - the number of samples contained in the input and output
 *            vectors
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                     0 = k <tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   One or more of the following pointers is NULL:
 *          -  pSrc,
 *          -  pDst,
 *          -  pSrcDst,
 *          -  pTapsQ15,
 *          -  pDelayLine, or
 *          -  pDelayLineIndex
 *    -   samplen < 0
 *    -   tapslen < 1
 *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 *
 */
OMXResult omxSP_FIR_Direct_S16_I (
    OMX_S16 *pSrcDst,
    OMX_INT sampLen,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex
);


/**
 * Function:  omxSP_FIR_Direct_S16_Sfs   (2.2.3.1.1)
 *
 * Description:
 * Block FIR filtering for 16-bit data type. This function applies
 * the FIR filter defined by the coefficient vector pTapsQ15 to a
 * vector of input data.  The output is multiplied by 2 to the negative
 * power of scalefactor (i.e., 2^-scalefactor) before returning to the caller.
 * Scaling and rounding conventions are defined in section 1.6.7.
 * The internal accumulator width must be at least 32 bits.
 * The result is undefined if any of the partially accumulated
 * values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrc    - pointer to the vector of input samples to which the
 *            filter is applied
 *   sampLen - the number of samples contained in the input and output
 *            vectors
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                     0 = k <tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *   scaleFactor - saturation fixed scalefactor
 *
 * Output Arguments:
 *
 *   pDst  - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   One or more of the following pointers is NULL:
 *          -  pSrc,
 *          -  pDst,
 *          -  pSrcDst,
 *          -  pTapsQ15,
 *          -  pDelayLine, or
 *          -  pDelayLineIndex
 *    -   samplen < 0
 *    -   tapslen < 1
 *    -   scaleFactor < 0
 *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 *
 */
OMXResult omxSP_FIR_Direct_S16_Sfs (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_INT sampLen,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FIR_Direct_S16_ISfs   (2.2.3.1.1)
 *
 * Description:
 * Block FIR filtering for 16-bit data type. This function applies
 * the FIR filter defined by the coefficient vector pTapsQ15 to a
 * vector of input data.  The output is multiplied by 2 to the negative
 * power of scalefactor (i.e., 2^-scalefactor) before returning to the caller.
 * Scaling and rounding conventions are defined in section 1.6.7.
 * The internal accumulator width must be at least 32 bits.
 * The result is undefined if any of the partially accumulated
 * values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the vector of input samples to which the
 *            filter is applied
 *   sampLen - the number of samples contained in the input and output
 *            vectors
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                     0 = k <tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *   scaleFactor - saturation fixed scalefactor
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   One or more of the following pointers is NULL:
 *          -  pSrc,
 *          -  pDst,
 *          -  pSrcDst,
 *          -  pTapsQ15,
 *          -  pDelayLine, or
 *          -  pDelayLineIndex
 *    -   samplen < 0
 *    -   tapslen < 1
 *    -   scaleFactor < 0
 *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 *
 */
OMXResult omxSP_FIR_Direct_S16_ISfs (
    OMX_S16 *pSrcDst,
    OMX_INT sampLen,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FIROne_Direct_S16   (2.2.3.1.2)
 *
 * Description:
 * Single-sample FIR filtering for 16-bit data type. These functions apply
 * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 * sample of input data. The result is saturated with rounding if the
 * operation produces a value outside the range of a signed 16-bit integer.
 * Rounding behavior is defined in:
 *       section 1.6.7 "Integer Scaling and Rounding Conventions".
 * The internal accumulator width must be at least 32 bits.  The result is
 * undefined if any of the partially accumulated values exceeds the range of a
 * signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   val      - the single input sample to which the filter is
 *            applied.
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (as defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                         0 = k < tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *
 * Output Arguments:
 *
 *   pResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    One or more of the following pointers is NULL:
 *            -  pResult,
 *            -  pTapsQ15,
 *            -  pDelayLine, or
 *            -  pDelayLineIndex
 *    -    tapslen < 1
 *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 *
 */
OMXResult omxSP_FIROne_Direct_S16 (
    OMX_S16 val,
    OMX_S16 *pResult,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex
);


/**
 * Function:  omxSP_FIROne_Direct_S16_I   (2.2.3.1.2)
 *
 * Description:
 * Single-sample FIR filtering for 16-bit data type. These functions apply
 * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 * sample of input data. The result is saturated with rounding if the
 * operation produces a value outside the range of a signed 16-bit integer.
 * Rounding behavior is defined in:
 *       section 1.6.7 "Integer Scaling and Rounding Conventions".
 * The internal accumulator width must be at least 32 bits.  The result is
 * undefined if any of the partially accumulated values exceeds the range of a
 * signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pValResult - pointer to the single input sample to which the filter is
 *            applied.
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (as defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                         0 = k < tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *
 * Output Arguments:
 *
 *   pValResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    One or more of the following pointers is NULL:
 *            -  pValResult,
 *            -  pTapsQ15,
 *            -  pDelayLine, or
 *            -  pDelayLineIndex
 *    -    tapslen < 1
 *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 *
 */
OMXResult omxSP_FIROne_Direct_S16_I (
    OMX_S16 *pValResult,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex
);


/**
 * Function:  omxSP_FIROne_Direct_S16_Sfs   (2.2.3.1.2)
 *
 * Description:
 * Single-sample FIR filtering for 16-bit data type. These functions apply
 * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 * sample of input data. The output is multiplied by 2 to the negative power
 * of scalefactor (i.e., 2^-scalefactor) before returning to the user.
 * Scaling and rounding conventions are defined in section 1.6.7.
 * The internal accumulator width must be at least 32 bits.
 * The result is undefined if any of the partially accumulated values exceeds
 * the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   val      - the single input sample to which the filter is
 *            applied.
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (as defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                         0 = k < tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *   scaleFactor - saturation fixed scaleFactor
 *
 * Output Arguments:
 *
 *   pResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    One or more of the following pointers is NULL:
 *            -  pResult,
 *            -  pTapsQ15,
 *            -  pDelayLine, or
 *            -  pDelayLineIndex
 *    -    tapslen < 1
 *    -    scaleFactor < 0
 *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 *
 */
OMXResult omxSP_FIROne_Direct_S16_Sfs (
    OMX_S16 val,
    OMX_S16 *pResult,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FIROne_Direct_S16_ISfs   (2.2.3.1.2)
 *
 * Description:
 * Single-sample FIR filtering for 16-bit data type. These functions apply
 * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 * sample of input data. The output is multiplied by 2 to the negative power
 * of scalefactor (i.e., 2^-scalefactor) before returning to the user.
 * Scaling and rounding conventions are defined in section 1.6.7.
 * The internal accumulator width must be at least 32 bits.
 * The result is undefined if any of the partially accumulated values exceeds
 * the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pValResult - the pointer to a single input sample to which the filter is
 *            applied.
 *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 *            represented in Q0.15 format (as defined in section 1.6.5). Given
 *            that:
 *                    -32768 = pTapsQ15(k) < 32768,
 *                         0 = k < tapsLen,
 *            the range on the actual filter coefficients is -1 = bK <1, and
 *            therefore coefficient normalization may be required during the
 *            filter design process.
 *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 *            (state). The user is responsible for allocation, initialization,
 *            and de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *   pDelayLineIndex - pointer to the filter memory index that is maintained
 *            internally by the function. The user should initialize the value
 *            of this index to zero.
 *   scaleFactor - saturation fixed scaleFactor
 *
 * Output Arguments:
 *
 *   pValResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    One or more of the following pointers is NULL:
 *            -  pValResult,
 *            -  pTapsQ15,
 *            -  pDelayLine, or
 *            -  pDelayLineIndex
 *    -    tapslen < 1
 *    -    scaleFactor < 0
 *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 *
 */
OMXResult omxSP_FIROne_Direct_S16_ISfs (
    OMX_S16 *pValResult,
    const OMX_S16 *pTapsQ15,
    OMX_INT tapsLen,
    OMX_S16 *pDelayLine,
    OMX_INT *pDelayLineIndex,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_IIR_Direct_S16   (2.2.3.2.1)
 *
 * Description:
 * Block IIR filtering for 16-bit data. This function applies the direct form
 * II IIR filter defined by the coefficient vector pTaps to a vector of input
 * data.  The internal accumulator width must be at least 32 bits, and the
 * result is saturated if the operation produces a value outside the range of
 * a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768)
 * for a negative overflow or 0x7fff (32767) for a positive overflow.  The
 * result is undefined if any of the partially accumulated values exceeds the
 * range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrc  - pointer to the vector of input samples to which the
 *            filter is applied
 *   len - the number of samples contained in both the input and output
 *            vectors
 *   pTaps - pointer to the 2L+2-element vector that contains the combined
 *            numerator and denominator filter coefficients from the system
 *            transfer function, H(z). Coefficient scaling and coefficient
 *            vector organization should follow the conventions described
 *            above. The value of the coefficient scaleFactor exponent must be
 *            non-negative (sf=0).
 *   order - the maximum of the degrees of the numerator and denominator
 *            coefficient polynomials from the system transfer function, H(z).
 *            In the notation of section 2.2.3.2, the parameter
 *            order=max(K,M)=L gives the maximum delay, in samples, used to
 *            compute each output sample.
 *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL:
 *             -  pSrc,
 *             -  pDst,
 *             -  pTaps, or
 *             -  pDelayLine.
 *    -    len < 0
 *    -    pTaps[order+1] < 0 (negative scaling)
 *    -    order < 1
 *
 */
OMXResult omxSP_IIR_Direct_S16 (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_INT len,
    const OMX_S16 *pTaps,
    OMX_INT order,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIR_Direct_S16_I   (2.2.3.2.1)
 *
 * Description:
 * Block IIR filtering for 16-bit data. This function applies the direct form
 * II IIR filter defined by the coefficient vector pTaps to a vector of input
 * data.  The internal accumulator width must be at least 32 bits, and the
 * result is saturated if the operation produces a value outside the range of
 * a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768)
 * for a negative overflow or 0x7fff (32767) for a positive overflow.  The
 * result is undefined if any of the partially accumulated values exceeds the
 * range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the vector of input samples to which the
 *            filter is applied
 *   len - the number of samples contained in both the input and output
 *            vectors
 *   pTaps - pointer to the 2L+2-element vector that contains the combined
 *            numerator and denominator filter coefficients from the system
 *            transfer function, H(z). Coefficient scaling and coefficient
 *            vector organization should follow the conventions described
 *            above. The value of the coefficient scaleFactor exponent must be
 *            non-negative (sf>=0).
 *   order - the maximum of the degrees of the numerator and denominator
 *            coefficient polynomials from the system transfer function, H(z).
 *            In the notation of section 2.2.3.2, the parameter
 *            order=max(K,M)=L gives the maximum delay, in samples, used to
 *            compute each output sample.
 *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL:
 *             -  pSrcDst,
 *             -  pTaps, or
 *             -  pDelayLine.
 *    -    len < 0
 *    -    pTaps[order+1] < 0 (negative scaling)
 *    -    order < 1
 *
 */
OMXResult omxSP_IIR_Direct_S16_I (
    OMX_S16 *pSrcDst,
    OMX_INT len,
    const OMX_S16 *pTaps,
    OMX_INT order,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIROne_Direct_S16   (2.2.3.2.2)
 *
 * Description:
 * Single sample IIR filtering for 16-bit data.  This function applies the
 * direct form II IIR filter defined by the coefficient vector pTaps to a
 * single sample of input data. The internal accumulator width must be at
 * least 32 bits, and the result is saturated if the operation produces a
 * value outside the range of a signed 16-bit integer, i.e., the output will
 * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 * positive overflow.  The result is undefined if any of the partially
 * accumulated values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   val - the single input sample to which the filter is
 *            applied.
 *   pTaps - pointer to the 2L+2 -element vector that contains the combined
 *            numerator and denominator filter coefficients from the system
 *            transfer function, H(z). Coefficient scaling and coefficient
 *            vector organization should follow the conventions described
 *            above. The value of the coefficient scaleFactor exponent must be
 *            non-negative (sf>=0).
 *   order - the maximum of the degrees of the numerator and denominator
 *            coefficient polynomials from the system transfer function, H(z).
 *            In the notation of section 2.2.3.2, the parameter
 *            order=max(K,M)=L gives the maximum delay, in samples, used to
 *            compute each output sample.
 *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL: pResult,
 *              pTaps, or pDelayLine.
 *    -    order < 1
 *    -    pTaps[order+1] < 0 (negative scaling)
 *
 */
OMXResult omxSP_IIROne_Direct_S16 (
    OMX_S16 val,
    OMX_S16 *pResult,
    const OMX_S16 *pTaps,
    OMX_INT order,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIROne_Direct_S16_I   (2.2.3.2.2)
 *
 * Description:
 * Single sample IIR filtering for 16-bit data.  This function applies the
 * direct form II IIR filter defined by the coefficient vector pTaps to a
 * single sample of input data. The internal accumulator width must be at
 * least 32 bits, and the result is saturated if the operation produces a
 * value outside the range of a signed 16-bit integer, i.e., the output will
 * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 * positive overflow.  The result is undefined if any of the partially
 * accumulated values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pValResult - pointer to the single input sample to which the filter is
 *            applied.
 *   pTaps - pointer to the 2L+2 -element vector that contains the combined
 *            numerator and denominator filter coefficients from the system
 *            transfer function, H(z). Coefficient scaling and coefficient
 *            vector organization should follow the conventions described
 *            above. The value of the coefficient scaleFactor exponent must be
 *            non-negative (sf>=0).
 *   order - the maximum of the degrees of the numerator and denominator
 *            coefficient polynomials from the system transfer function, H(z).
 *            In the notation of section 2.2.3.2, the parameter
 *            order=max(K,M)=L gives the maximum delay, in samples, used to
 *            compute each output sample.
 *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pValResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL:
 *              pValResult, pTaps, or pDelayLine.
 *    -    order < 1
 *    -    pTaps[order+1] < 0 (negative scaling)
 *
 */
OMXResult omxSP_IIROne_Direct_S16_I (
    OMX_S16 *pValResult,
    const OMX_S16 *pTaps,
    OMX_INT order,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIR_BiQuadDirect_S16   (2.2.3.3.1)
 *
 * Description:
 * Block biquad IIR filtering for 16-bit data type. This function applies the
 * direct form II biquad IIR cascade defined by the coefficient vector pTaps
 * to a vector of input data.  The internal accumulator width must be at least
 * 32 bits, and the result is saturated if the operation produces a value
 * outside the range of a signed 16-bit integer, i.e., the output will
 * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 * positive overflow.  The result is undefined if any of the partially
 * accumulated values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the vector of input samples to which the
 *            filter is applied
 *   len - the number of samples contained in both the input and output
 *            vectors
 *   pTaps - pointer to the 6P -element vector that contains the combined
 *            numerator and denominator filter coefficients from the biquad
 *            cascade. Coefficient scaling and coefficient vector organization
 *            should follow the conventions described above. The value of the
 *            coefficient scaleFactor exponent must be non-negative. (sfp>=0).
 *   numBiquad - the number of biquads contained in the IIR filter cascade:
 *            (P)
 *   pDelayLine - pointer to the 2P -element filter memory buffer (state).
 *            The user is responsible for allocation, initialization, and
 *            de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL: pSrc, pDst,
 *              pTaps, or pDelayLine.
 *    -    len < 0
 *    -    numBiquad < 1
 *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
 *
 */
OMXResult omxSP_IIR_BiQuadDirect_S16 (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_INT len,
    const OMX_S16 *pTaps,
    OMX_INT numBiquad,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIR_BiQuadDirect_S16_I   (2.2.3.3.1)
 *
 * Description:
 * Block biquad IIR filtering for 16-bit data type. This function applies the
 * direct form II biquad IIR cascade defined by the coefficient vector pTaps
 * to a vector of input data.  The internal accumulator width must be at least
 * 32 bits, and the result is saturated if the operation produces a value
 * outside the range of a signed 16-bit integer, i.e., the output will
 * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 * positive overflow.  The result is undefined if any of the partially
 * accumulated values exceeds the range of a signed 32-bit integer.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the vector of input samples to which the
 *            filter is applied
 *   len - the number of samples contained in both the input and output
 *            vectors
 *   pTaps - pointer to the 6P -element vector that contains the combined
 *            numerator and denominator filter coefficients from the biquad
 *            cascade. Coefficient scaling and coefficient vector organization
 *            should follow the conventions described above. The value of the
 *            coefficient scaleFactor exponent must be non-negative. (sfp>=0).
 *   numBiquad - the number of biquads contained in the IIR filter cascade:
 *            (P)
 *   pDelayLine - pointer to the 2P -element filter memory buffer (state).
 *            The user is responsible for allocation, initialization, and
 *            de-allocation. The filter memory elements are initialized to
 *            zero in most applications.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the vector of filtered output samples
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL:
 *              pSrcDst, pTaps, or pDelayLine.
 *    -    len < 0
 *    -    numBiquad < 1
 *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
 *
 */
OMXResult omxSP_IIR_BiQuadDirect_S16_I (
    OMX_S16 *pSrcDst,
    OMX_INT len,
    const OMX_S16 *pTaps,
    OMX_INT numBiquad,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIROne_BiQuadDirect_S16   (2.2.3.3.2)
 *
 * Description:
 * Single-sample biquad IIR filtering for 16-bit data type. This function
 * applies the direct form II biquad IIR cascade defined by the coefficient
 * vector pTaps to a single sample of input data.  The internal accumulator
 * width must be at least 32 bits, and the result is saturated if the
 * operation produces a value outside the range of a signed 16-bit integer,
 * i.e., the output will saturate to 0x8000 (-32768) for a negative overflow
 * or 0x7fff (32767) for a positive overflow.  The result is undefined if any
 * of the partially accumulated values exceeds the range of a signed 32-bit
 * integer.
 *
 * Input Arguments:
 *
 *   val   - the single input sample to which the filter is
 *            applied.
 *   pTaps - pointer to the 6P-element vector that contains the combined
 *            numerator and denominator filter coefficients from the biquad
 *            cascade. Coefficient scaling and coefficient vector organization
 *            should follow the conventions described above. The value of the
 *            coefficient scalefactor exponent must be non-negative: (sfp>=0).
 *   numBiquad - the number of biquads contained in the IIR filter cascade:
 *            (P)
 *   pDelayLine - pointer to the 2p-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL: pResult,
 *              pValResult, pTaps, or pDelayLine.
 *    -    numBiquad < 1
 *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
 *
 */
OMXResult omxSP_IIROne_BiQuadDirect_S16 (
    OMX_S16 val,
    OMX_S16 *pResult,
    const OMX_S16 *pTaps,
    OMX_INT numBiquad,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_IIROne_BiQuadDirect_S16_I   (2.2.3.3.2)
 *
 * Description:
 * Single-sample biquad IIR filtering for 16-bit data type. This function
 * applies the direct form II biquad IIR cascade defined by the coefficient
 * vector pTaps to a single sample of input data.  The internal accumulator
 * width must be at least 32 bits, and the result is saturated if the
 * operation produces a value outside the range of a signed 16-bit integer,
 * i.e., the output will saturate to 0x8000 (-32768) for a negative overflow
 * or 0x7fff (32767) for a positive overflow.  The result is undefined if any
 * of the partially accumulated values exceeds the range of a signed 32-bit
 * integer.
 *
 * Input Arguments:
 *
 *   pValResult - pointer to the single input sample to which the filter is
 *            applied.
 *   pTaps - pointer to the 6P-element vector that contains the combined
 *            numerator and denominator filter coefficients from the biquad
 *            cascade. Coefficient scaling and coefficient vector organization
 *            should follow the conventions described above. The value of the
 *            coefficient scalefactor exponent must be non-negative: (sfp>=0).
 *   numBiquad - the number of biquads contained in the IIR filter cascade:
 *            (P)
 *   pDelayLine - pointer to the 2p-element filter memory buffer (state). The
 *            user is responsible for allocation, initialization, and
 *            deallocation. The filter memory elements are initialized to zero
 *            in most applications.
 *
 * Output Arguments:
 *
 *   pValResult - pointer to the filtered output sample
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    one or more of the following pointers is NULL:
 *              pValResult, pTaps, or pDelayLine.
 *    -    numBiquad < 1
 *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
 *
 */
OMXResult omxSP_IIROne_BiQuadDirect_S16_I (
    OMX_S16 *pValResult,
    const OMX_S16 *pTaps,
    OMX_INT numBiquad,
    OMX_S32 *pDelayLine
);


/**
 * Function:  omxSP_FilterMedian_S32   (2.2.3.4.1)
 *
 * Description:
 * This function computes the median over the region specified by the median
 * mask for the every element of the input array. The median outputs are
 * stored in the corresponding elements of the output vector.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the input vector
 *   len - number of elements contained in the input and output vectors (0 <
 *            len < 65536)
 *   maskSize - median mask size; if an even value is specified, the function
 *            subtracts 1 and uses the odd value of the filter mask for median
 *            filtering (0 < maskSize < 256)
 *
 * Output Arguments:
 *
 *   pDst - pointer to the median-filtered output vector
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst.
 *    -    len < 0
 *    -    maskSize < 1 or maskSize> 255
 *    OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
 *              size
 *
 */
OMXResult omxSP_FilterMedian_S32 (
    const OMX_S32 *pSrc,
    OMX_S32 *pDst,
    OMX_INT len,
    OMX_INT maskSize
);


/**
 * Function:  omxSP_FilterMedian_S32_I   (2.2.3.4.1)
 *
 * Description:
 * This function computes the median over the region specified by the median
 * mask for the every element of the input array. The median outputs are
 * stored in the corresponding elements of the output vector.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input vector
 *   len - number of elements contained in the input and output vectors (0 <
 *            len < 65536)
 *   maskSize - median mask size; if an even value is specified, the function
 *            subtracts 1 and uses the odd value of the filter mask for median
 *            filtering (0 < maskSize < 256)
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the median-filtered output vector
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    pSrcDst is NULL.
 *    -    len < 0
 *    -    maskSize < 1 or maskSize> 255
 *    OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
 *              size
 *
 */
OMXResult omxSP_FilterMedian_S32_I (
    OMX_S32 *pSrcDst,
    OMX_INT len,
    OMX_INT maskSize
);


/**
 * Function:  omxSP_FFTInit_C_SC16   (2.2.4.1.2)
 *
 * Description:
 * These functions initialize the specification structures required for the
 * complex FFT and IFFT functions. Desired block length is specified as an
 * input. The function <FFTInit_C_SC16> is used to initialize the
 * specification structures for functions <FFTFwd_CToC_SC16_Sfs> and
 * <FFTInv_CToC_SC16_Sfs>.
 *
 * Memory for the specification structure *pFFTSpec
 * must be allocated prior to calling these functions and should be 4-byte
 * aligned for omxSP_FFTInit_C_SC16.
 *
 * The space required for *pFFTSpec, in bytes, can be
 * determined using <FFTGetBufSize_C_SC16>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length;
 *           valid in the range [0,12]
 *
 * Output Arguments:
 *
 *   pFFTSpec - pointer to initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr -no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTSpec is either NULL or violates the 4-byte alignment
 *              restrictions
 *    -   order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTInit_C_SC16 (
    OMXFFTSpec_C_SC16 *pFFTSpec,
    OMX_INT order
);


/**
 * Function:  omxSP_FFTInit_C_SC32   (2.2.4.1.2)
 *
 * Description:
 * These functions initialize the specification structures required for the
 * complex FFT and IFFT functions. Desired block length is specified as an
 * input. The function <FFTInit_C_SC32> is used to initialize
 * the specification structures for the functions <FFTFwd_CToC_SC32_Sfs> and
 * <FFTInv_CToC_SC32_Sfs>.
 *
 * Memory for the specification structure *pFFTSpec must be allocated prior
 * to calling these functions and should be 8-byte aligned for
 * omxSP_FFTInit_C_SC32.
 *
 * The space required for *pFFTSpec, in bytes, can be
 * determined using <FFTGetBufSize_C_SC32>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [0,12]
 *
 * Output Arguments:
 *
 *   pFFTSpec - pointer to initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr -no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTInit_C_SC32 (
    OMXFFTSpec_C_SC32 *pFFTSpec,
    OMX_INT order
);

/**
 * Function:  omxSP_FFTInit_C_FC32   (2.2.4.1.2)
 *
 * Description:
 * These functions initialize the specification structures required for the
 * complex FFT and IFFT functions. Desired block length is specified as an
 * input. The function <FFTInit_C_FC32> is used to initialize
 * the specification structures for the functions <FFTFwd_CToC_FC32_Sfs> and
 * <FFTInv_CToC_FC32_Sfs>.
 *
 * Memory for the specification structure *pFFTSpec must be allocated prior
 * to calling these functions and should be 8-byte aligned for
 * omxSP_FFTInit_C_FC32.
 *
 * The space required for *pFFTSpec, in bytes, can be
 * determined using <FFTGetBufSize_C_FC32>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [1,15]
 *
 * Output Arguments:
 *
 *   pFFTSpec - pointer to initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr -no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 1 or order > 15
 *
 */
OMXResult omxSP_FFTInit_C_FC32(
    OMXFFTSpec_C_FC32* pFFTSpec,
    OMX_INT order
);


/**
 * Function:  omxSP_FFTInit_R_S16S32   (2.2.4.1.4)
 *
 * Description:
 * These functions initialize specification structures required for the real
 * FFT and IFFT functions. The function <FFTInit_R_S16S32> is used to
 * initialize the specification structures for functions
 * <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>.
 *
 * Memory for
 * *pFFTFwdSpec must be allocated before calling these functions and should be
 * 8-byte aligned. The number of bytes required for *pFFTFwdSpec can be
 * determined using <FFTGetBufSize_R_S16S32>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [0,12]
 *
 * Output Arguments:
 *
 *   pFFTFwdSpec - pointer to the initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTInit_R_S16S32(
    OMXFFTSpec_R_S16S32* pFFTFwdSpec,
    OMX_INT order
);


/**
 * Function:  omxSP_FFTInit_R_S16
 *
 * Description:
 * These functions initialize specification structures required for the real
 * FFT and IFFT functions. The function <FFTInit_R_S16> is used
 * to initialize the specification structures for functions
 * <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>.
 *
 * Memory for *pFFTFwdSpec must be allocated before calling these functions
 * and should be 8-byte aligned.
 *
 * The number of bytes required for *pFFTFwdSpec can be
 * determined using <FFTGetBufSize_R_S16>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [1,12]
 *
 * Output Arguments:
 *
 *   pFFTFwdSpec - pointer to the initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 1 or order > 12
 *
 */
OMXResult omxSP_FFTInit_R_S16 (
    OMXFFTSpec_R_S32*pFFTFwdSpec,
    OMX_INT order
);

/**
 * Function:  omxSP_FFTInit_R_S32   (2.2.4.1.4)
 *
 * Description:
 * These functions initialize specification structures required for the real
 * FFT and IFFT functions. The function <FFTInit_R_S32> is used to initialize
 * the specification structures for functions <FFTFwd_RToCCS_S32_Sfs>
 * and <FFTInv_CCSToR_S32_Sfs>.
 *
 * Memory for *pFFTFwdSpec must be allocated before calling these functions
 * and should be 8-byte aligned.
 *
 * The number of bytes required for *pFFTFwdSpec can be
 * determined using <FFTGetBufSize_R_S32>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [0,12]
 *
 * Output Arguments:
 *
 *   pFFTFwdSpec - pointer to the initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTInit_R_S32 (
    OMXFFTSpec_R_S32*pFFTFwdSpec,
    OMX_INT order
);

/**
 * Function:  omxSP_FFTInit_R_F32
 *
 * Description:
 * These functions initialize specification structures required for the real
 * FFT and IFFT functions. The function <FFTInit_R_F32> is used to initialize
 * the specification structures for functions <FFTFwd_RToCCS_F32_Sfs>
 * and <FFTInv_CCSToR_F32_Sfs>.
 *
 * Memory for *pFFTFwdSpec must be allocated before calling these functions
 * and should be 8-byte aligned.
 *
 * The number of bytes required for *pFFTFwdSpec can be
 * determined using <FFTGetBufSize_R_F32>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [1,15]
 *
 * Output Arguments:
 *
 *   pFFTFwdSpec - pointer to the initialized specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
 *              restrictions
 *    -   order < 1 or order > 15
 *
 */
OMXResult omxSP_FFTInit_R_F32(
    OMXFFTSpec_R_F32* pFFTFwdSpec,
    OMX_INT order
);

/**
 * Function:  omxSP_FFTGetBufSize_C_SC16   (2.2.4.1.6)
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order complex FFT and IFFT functions. The function
 * <FFTGetBufSize_C_SC16> is used in conjunction with the 16-bit functions
 * <FFTFwd_CToC_SC16_Sfs> and <FFTInv_CToC_SC16_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [0,12]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    pSize is NULL
 *    -    order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTGetBufSize_C_SC16 (
    OMX_INT order,
    OMX_INT *pSize
);


/**
 * Function:  omxSP_FFTGetBufSize_C_SC32   (2.2.4.1.6)
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order complex FFT and IFFT functions. The function
 * <FFTGetBufSize_C_SC32> is used in conjunction with the 32-bit functions
 * <FFTFwd_CToC_SC32_Sfs> and <FFTInv_CToC_SC32_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [0,12]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    pSize is NULL
 *    -    order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTGetBufSize_C_SC32 (
    OMX_INT order,
    OMX_INT *pSize
);

/**
 * Function:  omxSP_FFTGetBufSize_C_FC32
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order complex FFT and IFFT functions. The function
 * <FFTGetBufSize_C_FC32> is used in conjunction with the 32-bit functions
 * <FFTFwd_CToC_FC32_Sfs> and <FFTInv_CToC_FC32_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the desired block length; valid in the range
 *            [1,15]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 *              following is true:
 *    -    pSize is NULL
 *    -    order < 1 or order > 15
 *
 */
OMXResult omxSP_FFTGetBufSize_C_FC32(
    OMX_INT order,
    OMX_INT* pSize
);


/**
 * Function:  omxSP_FFTGetBufSize_R_S16S32   (2.2.4.1.8)
 *
 * Description:
 * order These functions compute the size of the specification structure
 * required for the length 2^order real FFT and IFFT functions. The function
 * <FFTGetBufSize_R_S16S32> is used in conjunction with the 16-bit functions
 * <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the length; valid in the range [0,12]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments The function returns
 *              OMX_Sts_BadArgErr if one or more of the following is true:
 *    pSize is NULL
 *    order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTGetBufSize_R_S16S32(
    OMX_INT order,
    OMX_INT* pSize
);


/**
 * Function:  omxSP_FFTGetBufSize_R_S16
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order real FFT and IFFT functions.  The function
 * <FFTGetBufSize_R_S16> is used in conjunction with the 16-bit
 * functions <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the length; valid in the range
 *   [1,12]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments The function returns
 *              OMX_Sts_BadArgErr if one or more of the following is true:
 *    pSize is NULL
 *    order < 1 or order > 12
 *
 */
OMXResult omxSP_FFTGetBufSize_R_S16 (
    OMX_INT order,
    OMX_INT *pSize
);

/**
 * Function:  omxSP_FFTGetBufSize_R_S32   (2.2.4.1.8)
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order real FFT and IFFT functions.  The function
 * <FFTGetBufSize_R_S32> is used in conjunction with the 32-bit functions
 * <FFTFwd_RToCCS_S32_Sfs> and <FFTInv_CCSToR_S32_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the length; valid in the range [0,12]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments The function returns
 *              OMX_Sts_BadArgErr if one or more of the following is true:
 *    pSize is NULL
 *    order < 0 or order > 12
 *
 */
OMXResult omxSP_FFTGetBufSize_R_S32 (
    OMX_INT order,
    OMX_INT *pSize
);

/**
 * Function:  omxSP_FFTGetBufSize_R_F32
 *
 * Description:
 * These functions compute the size of the specification structure
 * required for the length 2^order real FFT and IFFT functions.  The function
 * <FFTGetBufSize_R_F32> is used in conjunction with the 32-bit functions
 * <FFTFwd_RToCCS_F32_Sfs> and <FFTInv_CCSToR_F32_Sfs>.
 *
 * Input Arguments:
 *
 *   order - base-2 logarithm of the length; valid in the range [1,15]
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments The function returns
 *              OMX_Sts_BadArgErr if one or more of the following is true:
 *    pSize is NULL
 *    order < 1 or order > 15
 *
 */
OMXResult omxSP_FFTGetBufSize_R_F32(
    OMX_INT order,
    OMX_INT* pSize
);


/**
 * Function:  omxSP_FFTFwd_CToC_SC16_Sfs   (2.2.4.2.2)
 *
 * Description:
 * Compute an FFT for a complex signal of length of 2^order,
 * where 0 <= order <= 12.
 * Transform length is determined by the specification structure, which
 * must be initialized prior to calling the FFT function using the appropriate
 * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
 * between the input and output sequences can be expressed in terms of the
 * DFT, i.e.,
 *
 *      X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
 *      k = 0,1,2,..., N-1
 *      N = 2^order
 *
 * Input Arguments:
 *   pSrc - pointer to the input signal, a complex-valued vector of length 2^order;
 *            must be aligned on a 32 byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scale factor; the range for is [0,16]
 *
 * Output Arguments:
 *   pDst - pointer to the complex-valued output vector, of length 2^order;
 *          must be aligned on an 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -    pSrc or pDst is not 32-byte aligned
 *    -    scaleFactor<0 or scaleFactor>16
 *
 */

OMXResult omxSP_FFTFwd_CToC_SC16_Sfs (
    const OMX_SC16 *pSrc,
    OMX_SC16 *pDst,
    const OMXFFTSpec_C_SC16 *pFFTSpec,
    OMX_INT scaleFactor
);

OMXResult omxSP_FFTFwd_CToC_SC16_Sfs_neon (
    const OMX_SC16 *pSrc,
    OMX_SC16 *pDst,
    const OMXFFTSpec_C_SC16 *pFFTSpec,
    OMX_INT scaleFactor
);

/**
 * Function:  omxSP_FFTFwd_CToC_SC32_Sfs   (2.2.4.2.2)
 *
 * Description:
 * Compute an FFT for a complex signal of length of 2^order,
 * where 0 <= order <= 12.
 * Transform length is determined by the specification structure, which
 * must be initialized prior to calling the FFT function using the appropriate
 * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
 * between the input and output sequences can be expressed in terms of the
 * DFT, i.e.,
 *
 *      X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
 *      k = 0,1,2,..., N-1
 *      N = 2^order
 *
 * Input Arguments:
 *   pSrc - pointer to the input signal, a complex-valued vector of length 2^order;
 *            must be aligned on a 32 byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scale factor; the range is [0,32]
 *
 * Output Arguments:
 *   pDst - pointer to the complex-valued output vector, of length 2^order; must be
 *            aligned on an 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -    pSrc or pDst is not 32-byte aligned
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTFwd_CToC_SC32_Sfs (
    const OMX_SC32 *pSrc,
    OMX_SC32 *pDst,
    const OMXFFTSpec_C_SC32 *pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTInv_CToC_SC16_Sfs   (2.2.4.2.4)
 *
 * Description:
 * These functions compute an inverse FFT for a complex signal of  length
 * of 2^order, where 0 <= order <= 12. Transform length is determined by the
 * specification structure, which must be initialized prior to calling the FFT
 * function using the appropriate helper, i.e., <FFTInit_C_sc32> or
 * <FFTInit_C_SC16>. The relationship between the input and output sequences
 * can be expressed in terms of the IDFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - scale factor of the output. Valid range is [0,16].
 *
 * Output Arguments:
 *   order
 *   pDst - pointer to the complex-valued output signal, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    Positive value - the shift scale that was performed inside
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -   pSrc or pDst is not 32-byte aligned
 *    -   scaleFactor<0 or scaleFactor>16
 *
 */
OMXResult omxSP_FFTInv_CToC_SC16_Sfs (
    const OMX_SC16 *pSrc,
    OMX_SC16 *pDst,
    const OMXFFTSpec_C_SC16 *pFFTSpec,
    OMX_INT scaleFactor
);

OMXResult omxSP_FFTInv_CToC_SC16_Sfs_neon (
    const OMX_SC16 *pSrc,
    OMX_SC16 *pDst,
    const OMXFFTSpec_C_SC16 *pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTInv_CToC_SC32_Sfs   (2.2.4.2.4)
 *
 * Description:
 * These functions compute an inverse FFT for a complex signal of length
 * of 2^order, where 0 <= order <= 12. Transform length is determined by the
 * specification structure, which must be initialized prior to calling the FFT
 * function using the appropriate helper, i.e., <FFTInit_C_sc32> or
 * <FFTInit_C_SC16>. The relationship between the input and output sequences
 * can be expressed in terms of the IDFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - scale factor of the output. Valid range is [0,32].
 *
 * Output Arguments:
 *   order
 *   pDst - pointer to the complex-valued output signal, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -   pSrc or pDst is not 32-byte aligned
 *    -   scaleFactor<0 or scaleFactor>32
 *
 */
OMXResult omxSP_FFTInv_CToC_SC32_Sfs (
    const OMX_SC32 *pSrc,
    OMX_SC32 *pDst,
    const OMXFFTSpec_C_SC32 *pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTFwd_RToCCS_S16S32_Sfs   (2.2.4.4.2)
 *
 * Description:
 * These functions compute an FFT for a real-valued signal of length of 2^order,
 * where 0 <= order <= 12. Transform length is determined by the
 * specification structure, which must be initialized prior to calling the FFT
 * function using the appropriate helper, i.e., <FFTInit_R_S16S32>.
 * The relationship between the input and output sequences
 * can be expressed in terms of the DFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * The conjugate-symmetric output sequence is represented using a CCS vector,
 * which is of length N+2, and is organized as follows:
 *
 *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
 *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components
 * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
 * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the
 * foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the real-valued input sequence, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scale factor; valid range is [0, 32]
 *
 * Output Arguments:
 *   pDst - pointer to output sequence, represented using CCS format, of
 *            length (2^order)+2; must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true:
 *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTFwd_RToCCS_S16S32_Sfs (
    const OMX_S16 *pSrc,
    OMX_S32 *pDst,
    const OMXFFTSpec_R_S16S32 *pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTFwd_RToCCS_S16_Sfs
 *
 * Description:
 * These functions compute an FFT for a real-valued signal of length of 2^order,
 * where 0 < order <= 12. Transform length is determined by the
 * specification structure, which must be initialized prior to calling the FFT
 * function using the appropriate helper, i.e., <FFTInit_R_S16>.
 * The relationship between the input and output sequences can
 * be expressed in terms of the DFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * The conjugate-symmetric output sequence is represented using a CCS vector,
 * which is of length N+2, and is organized as follows:
 *
 *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
 *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components
 * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
 * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to
 * the foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the real-valued input sequence, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scale factor; valid range is [0, 16]
 *
 * Output Arguments:
 *   pDst - pointer to output sequence, represented using CCS format, of
 *            length (2^order)+2; must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if one or more of followings is true:
 *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >16
 *
 */
OMXResult omxSP_FFTFwd_RToCCS_S16_Sfs (
    const OMX_S16* pSrc,
    OMX_S16* pDst,
    const OMXFFTSpec_R_S16* pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTFwd_RToCCS_S32_Sfs   (2.2.4.4.2)
 *
 * Description:
 * These functions compute an FFT for a real-valued signal of length of 2^order,
 * where 0 <= order <= 12. Transform length is determined by the
 * specification structure, which must be initialized prior to calling the FFT
 * function using the appropriate helper, i.e., <FFTInit_R_S32>.
 * The relationship between the input and output sequences
 * can be expressed in terms of the DFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * The conjugate-symmetric output sequence is represented using a CCS vector,
 * which is of length N+2, and is organized as follows:
 *
 *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
 *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components
 * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
 * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the
 * foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the real-valued input sequence, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scale factor; valid range is [0, 32]
 *
 * Output Arguments:
 *   pDst - pointer to output sequence, represented using CCS format, of
 *            length (2^order)+2; must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true:
 *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTFwd_RToCCS_S32_Sfs (
    const OMX_S32 *pSrc,
    OMX_S32 *pDst,
    const OMXFFTSpec_R_S32 *pFFTSpec,
    OMX_INT scaleFactor
);

/**
 * Function:  omxSP_FFTFwd_CToC_FC32_Sfs   (2.2.4.2.2)
 *
 * Description:
 * Compute an FFT for a complex signal of length of 2^order,
 * where 0 <= order <= 15.
 * Transform length is determined by the specification structure, which
 * must be initialized prior to calling the FFT function using the appropriate
 * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
 * between the input and output sequences can be expressed in terms of the
 * DFT, i.e.,
 *
 *      X[k] = SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
 *      k = 0,1,2,..., N-1
 *      N = 2^order
 *
 * Input Arguments:
 *   pSrc - pointer to the input signal, a complex-valued vector of length
 *            2^order; must be aligned on a 32 byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *
 * Output Arguments:
 *   pDst - pointer to the complex-valued output vector, of length 2^order;
 *            must be aligned on an 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -    pSrc or pDst is not 32-byte aligned
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTFwd_CToC_FC32_Sfs (
    const OMX_FC32 *pSrc,
    OMX_FC32 *pDst,
    const OMXFFTSpec_C_FC32 *pFFTSpec
);

/**
 * Function:  omxSP_FFTFwd_RToCCS_F32_Sfs
 *
 * Description:
 * These functions compute an FFT for a real-valued signal of length
 * of 2^order, where 0 <= order <= 12. Transform length is determined
 * by the specification structure, which must be initialized prior to
 * calling the FFT function using the appropriate helper, i.e.,
 * <FFTInit_R_F32>. The relationship between the input and output
 * sequences can be expressed in terms of the DFT, i.e.:
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * The conjugate-symmetric output sequence is represented using a CCS vector,
 * which is of length N+2, and is organized as follows:
 *
 *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
 *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary
 * components for FFT bin 'n'. Bins are numbered from 0 to N/2, where
 * N is the FFT length. Bin index 0 corresponds to the DC component,
 * and bin index N/2 corresponds to the foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the real-valued input sequence, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *
 * Output Arguments:
 *   pDst - pointer to output sequence, represented using CCS format, of
 *            length (2^order)+2; must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error

 *    OMX_Sts_BadArgErr - bad arguments, if one or more of the
 *    following is true: - one of the pointers pSrc, pDst, or pFFTSpec
 *    is NULL - pSrc or pDst is not aligned on a 32-byte boundary
 *
 */
OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec
);

/**
 * Function:  omxSP_FFTInv_CCSToR_S32S16_Sfs   (2.2.4.4.4)
 *
 * Description:
 * These functions compute the inverse FFT for a conjugate-symmetric input
 * sequence.  Transform length is determined by the specification structure,
 * which must be initialized prior to calling the FFT function using
 * <FFTInit_R_S16S32>. For a transform of length M, the input sequence is
 * represented using a packed CCS vector of length M+2, and is organized
 * as follows:
 *
 *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
 *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n.
 * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
 * corresponds to the DC component, and bin index M/2 corresponds to the
 * foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input sequence represented using
 *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
 *            boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scalefactor; range is [0,16]
 *
 * Output Arguments:
 *   pDst - pointer to the real-valued output sequence, of length 2^order ; must be
 *            aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
 *    -    pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >16
 *
 */
OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs (
    const OMX_S32 *pSrc,
    OMX_S16 *pDst,
    const OMXFFTSpec_R_S16S32 *pFFTSpec,
    OMX_INT scaleFactor
);


/**
 * Function:  omxSP_FFTInv_CCSToR_S16_Sfs
 *
 * Description:
 * These functions compute the inverse FFT for a conjugate-symmetric input
 * sequence.  Transform length is determined by the specification structure,
 * which must be initialized prior to calling the FFT function using
 * <FFTInit_R_S16>. For a transform of length M, the input
 * sequence is represented using a packed CCS vector of length
 * M+2, and is organized as follows:
 *
 *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
 *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components
 * for FFT bin n.
 * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
 * corresponds to the DC component, and bin index M/2 corresponds to the
 * foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input sequence represented using
 *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
 *            boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scalefactor; range is [0,16]
 *
 * Output Arguments:
 *   pDst - pointer to the real-valued output sequence, of length 2^order ; must
 *            be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
 *    -    pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >16
 *
 */
OMXResult omxSP_FFTInv_CCSToR_S16_Sfs (
    const OMX_S16* pSrc,
    OMX_S16* pDst,
    const OMXFFTSpec_R_S16* pFFTSpec,
    OMX_INT scaleFactor
);

/**
 * Function:  omxSP_FFTInv_CCSToR_S32_Sfs   (2.2.4.4.4)
 *
 * Description:
 * These functions compute the inverse FFT for a conjugate-symmetric input
 * sequence.  Transform length is determined by the specification structure,
 * which must be initialized prior to calling the FFT function using
 * <FFTInit_R_S32>. For a transform of length M, the input sequence is
 * represented using a packed CCS vector of length M+2, and is organized
 * as follows:
 *
 *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
 *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n.
 * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
 * corresponds to the DC component, and bin index M/2 corresponds to the
 * foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input sequence represented using
 *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
 *            boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *   scaleFactor - output scalefactor; range is [0,32]
 *
 * Output Arguments:
 *   pDst - pointer to the real-valued output sequence, of length 2^order ; must be
 *            aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
 *    -    pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTInv_CCSToR_S32_Sfs (
    const OMX_S32 *pSrc,
    OMX_S32 *pDst,
    const OMXFFTSpec_R_S32 *pFFTSpec,
    OMX_INT scaleFactor
);

/**
 * Function:  omxSP_FFTInv_CToC_FC32_Sfs   (2.2.4.2.4)
 *
 * Description:
 * These functions compute an inverse FFT for a complex signal of
 * length of 2^order, where 0 <= order <= 15. Transform length is
 * determined by the specification structure, which must be
 * initialized prior to calling the FFT function using the appropriate
 * helper, i.e., <FFTInit_C_FC32>. The relationship between the input
 * and output sequences can be expressed in terms of the IDFT, i.e.:
 *
 *     x[n] = SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
 *          must be aligned on a 32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized specification
 *            structure
 *
 * Output Arguments:
 *   order
 *   pDst - pointer to the complex-valued output signal, of length 2^order;
 *          must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
 *              is true:
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or
 *              pFFTSpec.
 *    -   pSrc or pDst is not 32-byte aligned
 *    -   scaleFactor<0 or scaleFactor>32
 *
 */
OMXResult omxSP_FFTInv_CToC_FC32_Sfs (
    const OMX_FC32 *pSrc,
    OMX_FC32 *pDst,
    const OMXFFTSpec_C_FC32 *pFFTSpec
);

/**
 * Function:  omxSP_FFTInv_CCSToR_F32_Sfs
 *
 * Description:
 * These functions compute the inverse FFT for a conjugate-symmetric input
 * sequence.  Transform length is determined by the specification structure,
 * which must be initialized prior to calling the FFT function using
 * <FFTInit_R_F32>. For a transform of length M, the input sequence is
 * represented using a packed CCS vector of length M+2, and is organized
 * as follows:
 *
 *   Index:   0  1  2    3    4    5    . . .  M-2       M-1      M      M+1
 *   Comp:  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
 *
 * where R[n] and I[n], respectively, denote the real and imaginary
 * components for FFT bin n. Bins are numbered from 0 to M/2, where M
 * is the FFT length.  Bin index 0 corresponds to the DC component,
 * and bin index M/2 corresponds to the foldover frequency.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input sequence represented
 *          using CCS format, of length (2^order) + 2; must be aligned on a
 *          32-byte boundary.
 *   pFFTSpec - pointer to the preallocated and initialized
 *              specification structure
 *
 * Output Arguments:
 *   pDst - pointer to the real-valued output sequence, of length
 *          2^order ; must be aligned on a 32-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *
 *    OMX_Sts_BadArgErr - bad arguments if one or more of the
 *      following is true:
 *    -    pSrc, pDst, or pFFTSpec is NULL
 *    -    pSrc or pDst is not aligned on a 32-byte boundary
 *    -    scaleFactor<0 or scaleFactor >32
 *
 */
OMXResult omxSP_FFTInv_CCSToR_F32_Sfs(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec
);

/*
 * This block sets things up appropriately for run-time or build-time selection
 * of NEON implementations.
 */
#if defined(__arm__) || defined(__aarch64__)
/*
 * Generic versions. Just like their *_Sfs counterparts, but automatically
 * detect whether NEON is available or not and choose the appropriate routine.
 */
#if defined(DL_ARM_NEON_OPTIONAL)
extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec
);
extern OMXResult (*omxSP_FFTInv_CCSToR_F32)(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec);
#elif defined(DL_ARM_NEON)
/* Build-time NEON selection. */
#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs
#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs
#else
/* Build-time non-NEON selection. */
#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_CCSToR_F32_vfp
#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_vfp
#endif  /* defined(DL_ARM_NEON_OPTIONAL) */

#if defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON)
/* Non-NEON versions. */
OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec
);

OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp(
    const OMX_F32* pSrc,
    OMX_F32* pDst,
    const OMXFFTSpec_R_F32* pFFTSpec
);

OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp (
    const OMX_FC32 *pSrc,
    OMX_FC32 *pDst,
    const OMXFFTSpec_C_FC32 *pFFTSpec
);

OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp (
    const OMX_FC32 *pSrc,
    OMX_FC32 *pDst,
    const OMXFFTSpec_C_FC32 *pFFTSpec
);
#endif  /* defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON) */

#else
/* Build-time non-ARM selection. */
#define omxSP_FFTInv_RToCCS_F32 omxSP_FFTInv_RToCCS_F32_Sfs
#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs
#endif  /* defined(__arm__) || defined(__aarch64__) */

#ifdef __cplusplus
}
#endif

#endif /** end of #define _OMXSP_H_ */

/** EOF */