Bug 926838 - [Part 5] Re-import Google's modifications. r=gerv
☠☠ backed out by 3fbbaabff67a ☠ ☠
authorPaul Adenot <paul@paul.cx>
Mon, 04 May 2015 17:19:03 +0200
changeset 273720 1ada6df926ba28089114de4ab58acf4a39324926
parent 273719 2a08b161b02ea5c9f49e1b6ec82cdbad717c159e
child 273721 5b6ef91bfe0133e1d1c7344b464ccb0f39b753dd
push id863
push userraliiev@mozilla.com
push dateMon, 03 Aug 2015 13:22:43 +0000
treeherdermozilla-release@f6321b14228d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersgerv
bugs926838
milestone40.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 926838 - [Part 5] Re-import Google's modifications. r=gerv
media/openmax_dl/dl/api/omxtypes.h
media/openmax_dl/dl/sp/api/omxSP.h
--- a/media/openmax_dl/dl/api/omxtypes.h
+++ b/media/openmax_dl/dl/api/omxtypes.h
@@ -30,16 +30,31 @@
  *
  */
   
 #ifndef _OMXTYPES_H_
 #define _OMXTYPES_H_
 
 #include <limits.h> 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Maximum FFT order supported by the twiddle table.  Only used by the
+ * float FFT routines. Must be consistent with the table in
+ * armSP_FFT_F32TwiddleTable.c.
+ */
+#ifdef BIG_FFT_TABLE
+#define TWIDDLE_TABLE_ORDER 15
+#else
+#define TWIDDLE_TABLE_ORDER 12
+#endif
+
 #define OMX_IN
 #define OMX_OUT
 #define OMX_INOUT
 
 
 typedef enum {
     
     /* Mandatory return codes - use cases are explicitly described for each function */
@@ -188,20 +203,34 @@ typedef struct
   OMX_S64 Im; /** Imaginary part */	
 	
 } OMX_SC64; /** Signed 64-bit complex number */
 
 
 /* OMX_F32 */
 typedef float OMX_F32; /** Single precision floating point,IEEE 754 */
 
-
 /* OMX_F64 */
 typedef double OMX_F64; /** Double precision floating point,IEEE 754 */
 
+/* OMX_FC32 */
+typedef struct
+{
+  OMX_F32 Re; /** Real part */
+  OMX_F32 Im; /** Imaginary part */	
+
+} OMX_FC32; /** single precision floating point complex number */
+
+/* OMX_FC64 */
+typedef struct
+{
+  OMX_F64 Re; /** Real part */
+  OMX_F64 Im; /** Imaginary part */	
+
+} OMX_FC64; /** double precision floating point complex number */
 
 /* OMX_INT */
 typedef int OMX_INT; /** signed integer corresponding to machine word length, has maximum signed value INT_MAX*/
 
 
 #define OMX_MIN_S8  	   	(-128)
 #define OMX_MIN_U8  		0
 #define OMX_MIN_S16		 	(-32768)
@@ -246,9 +275,12 @@ typedef struct
 /** Defines the dimensions of a rectangle, or region of interest in an image */
 typedef struct 
 {
  OMX_INT width;  /** Width of the rectangle, in the x-direction */
  OMX_INT height; /** Height of the rectangle, in the y-direction */
 	
 } OMXSize;
 
+#ifdef __cplusplus
+}
+#endif
 #endif /* _OMXTYPES_H_ */
--- a/media/openmax_dl/dl/sp/api/omxSP.h
+++ b/media/openmax_dl/dl/sp/api/omxSP.h
@@ -30,29 +30,31 @@
  *
  */
 
 /* *****************************************************************************************/
 
 #ifndef _OMXSP_H_
 #define _OMXSP_H_
 
-#include "omxtypes.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)
@@ -1399,16 +1401,57 @@ OMXResult omxSP_FFTInit_C_SC16 (
  *    -   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 
@@ -1434,24 +1477,63 @@ OMXResult omxSP_FFTInit_C_SC32 (
  *    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,
+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>. 
  *
@@ -1480,17 +1562,54 @@ OMXResult omxSP_FFTInit_R_S16S32 (
  *    -   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 
@@ -1550,16 +1669,48 @@ OMXResult omxSP_FFTGetBufSize_C_SC16 (
  *    -    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 
@@ -1579,23 +1730,55 @@ OMXResult omxSP_FFTGetBufSize_C_SC32 (
  *    
  *    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 (
+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>. 
@@ -1618,16 +1801,48 @@ OMXResult omxSP_FFTGetBufSize_R_S16S32 (
  *    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. 
@@ -1658,24 +1873,30 @@ OMXResult omxSP_FFTGetBufSize_R_S32 (
  *    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 
@@ -1734,41 +1955,50 @@ OMXResult omxSP_FFTFwd_CToC_SC32_Sfs (
  *     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]. 
+ *   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:
- *    
- *    OMX_Sts_NoErr - no error 
+ *  
+ *    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 
@@ -1862,16 +2092,69 @@ OMXResult omxSP_FFTInv_CToC_SC32_Sfs (
 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 
@@ -1916,17 +2199,143 @@ OMXResult omxSP_FFTFwd_RToCCS_S16S32_Sfs
  */
 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 
@@ -1966,16 +2375,63 @@ OMXResult omxSP_FFTFwd_RToCCS_S32_Sfs (
 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 
@@ -2014,17 +2470,138 @@ OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs
  */
 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
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /** end of #define _OMXSP_H_ */
 
 /** EOF */