Add m-esr52 at 52.6.0

2 files changed, 2712 insertions, 0 deletions

diff --git a/media/openmax_dl/dl/sp/api/armSP.h b/media/openmax_dl/dl/sp/api/armSP.h
new file mode 100644
index 000000000..f615a87c7
--- /dev/null
+++ b/media/openmax_dl/dl/sp/api/armSP.h
@@ -0,0 +1,92 @@
+/*
+ *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ *
+ *  This file was originally licensed as follows. It has been
+ *  relicensed with permission from the copyright holders.
+ */
+
+/**
+ * 
+ * File Name:  armSP.h
+ * OpenMAX DL: v1.0.2
+ * Last Modified Revision:   7014
+ * Last Modified Date:       Wed, 01 Aug 2007
+ * 
+ * (c) Copyright 2007-2008 ARM Limited. All Rights Reserved.
+ * 
+ * 
+ *   
+ * File: armSP.h
+ * Brief: Declares API's/Basic Data types used across the OpenMAX Signal Processing domain
+ *
+ */
+#ifndef _armSP_H_
+#define _armSP_H_
+
+#include "dl/api/omxtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** FFT Specific declarations */
+extern  OMX_S32 armSP_FFT_S32TwiddleTable[1026];
+extern OMX_F32 armSP_FFT_F32TwiddleTable[];
+
+typedef struct  ARMsFFTSpec_SC32_Tag 
+{
+    OMX_U32     N;
+    OMX_U16     *pBitRev;    
+    OMX_SC32    *pTwiddle;
+    OMX_SC32    *pBuf;
+}ARMsFFTSpec_SC32;
+
+
+typedef struct  ARMsFFTSpec_SC16_Tag 
+{
+    OMX_U32     N;
+    OMX_U16     *pBitRev;    
+    OMX_SC16    *pTwiddle;
+    OMX_SC16    *pBuf;
+}ARMsFFTSpec_SC16;
+
+typedef struct  ARMsFFTSpec_R_SC32_Tag 
+{
+    OMX_U32     N;
+    OMX_U16     *pBitRev;    
+    OMX_SC32    *pTwiddle;
+    OMX_S32     *pBuf;
+}ARMsFFTSpec_R_SC32;
+
+typedef struct ARMsFFTSpec_R_FC32_Tag
+{
+    OMX_U32 N;
+    OMX_U16* pBitRev;
+    OMX_FC32* pTwiddle;
+    OMX_F32* pBuf;
+} ARMsFFTSpec_R_FC32;
+
+typedef struct ARMsFFTSpec_FC32_Tag
+{
+    OMX_U32 N;
+    OMX_U16* pBitRev;
+    OMX_FC32* pTwiddle;
+    OMX_FC32* pBuf;
+} ARMsFFTSpec_FC32;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*End of File*/
+
+
+
diff --git a/media/openmax_dl/dl/sp/api/omxSP.h b/media/openmax_dl/dl/sp/api/omxSP.h
new file mode 100644
index 000000000..f2a3f5db6
--- /dev/null
+++ b/media/openmax_dl/dl/sp/api/omxSP.h
@@ -0,0 +1,2620 @@
+/**
+ * File: omxSP.h
+ * Brief: OpenMAX DL v1.0.2 - Signal Processing library
+ *
+ * Copyright (c) 2005-2008,2015 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+ * KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+ * SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+ *    https://www.khronos.org/registry/
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ *
+ */
+
+/* *****************************************************************************************/
+
+#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
+);
+#ifdef __arm__
+/*
+ * Non-NEON version
+ */    
+OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp (
+    const OMX_FC32 *pSrc,
+    OMX_FC32 *pDst,
+    const OMXFFTSpec_C_FC32 *pFFTSpec
+);
+#endif
+
+/**
+ * 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
+);
+
+#ifdef __arm__
+/*
+ * Non-NEON version of omxSP_FFTFwd_RToCCS_F32_Sfs
+ */    
+OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp(
+    const OMX_F32* pSrc,
+    OMX_F32* pDst,
+    const OMXFFTSpec_R_F32* pFFTSpec
+);
+
+/*
+ * Just like omxSP_FFTFwd_RToCCS_F32_Sfs, but automatically detects
+ * whether NEON is available or not and chooses the appropriate
+ * routine.
+ */    
+extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)(
+    const OMX_F32* pSrc,
+    OMX_F32* pDst,
+    const OMXFFTSpec_R_F32* pFFTSpec
+);
+#else
+#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs
+#endif
+
+/**
+ * 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
+);
+#ifdef __arm__
+/*
+ * Non-NEON version
+ */    
+OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp (
+    const OMX_FC32 *pSrc,
+    OMX_FC32 *pDst,
+    const OMXFFTSpec_C_FC32 *pFFTSpec
+);
+#endif
+
+/**
+ * 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
+);
+
+#ifdef __arm__
+/*
+ * Non-NEON version of omxSP_FFTInv_CCSToR_F32_Sfs
+ */    
+OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp(
+    const OMX_F32* pSrc,
+    OMX_F32* pDst,
+    const OMXFFTSpec_R_F32* pFFTSpec
+);
+
+/*
+ * Just like omxSP_FFTInv_CCSToR_F32_Sfs, but automatically detects
+ * whether NEON is available or not and chooses the appropriate
+ * routine.
+ */    
+extern OMXResult (*omxSP_FFTInv_CCSToR_F32)(
+    const OMX_F32* pSrc,
+    OMX_F32* pDst,
+    const OMXFFTSpec_R_F32* pFFTSpec);
+#else
+#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs    
+#endif
+
+/*
+ * Just like omxSP_FFTInv_CCSToR_F32_Sfs, but does not scale the result.
+ * (Actually, we multiple by two for consistency with other FFT routines in
+ * use.)
+ */
+OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_unscaled(
+    const OMX_F32* pSrc,
+    OMX_F32* pDst,
+    const OMXFFTSpec_R_F32* pFFTSpec
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /** end of #define _OMXSP_H_ */
+
+/** EOF */
+