webrtc / deps / third_party / openmax / 21c8abe416eb1cdf6f759cdce72e715e7f262282 / . / dl / sp / api / omxSP.h

/** | |

* File: omxSP.h | |

* Brief: OpenMAX DL v1.0.2 - Signal Processing library | |

* | |

* Copyright 2005-2008 The Khronos Group Inc. All Rights Reserved. | |

* | |

* These materials are protected by copyright laws and contain material | |

* proprietary to the Khronos Group, Inc. You may use these materials | |

* for implementing Khronos specifications, without altering or removing | |

* any trademark, copyright or other notice from the specification. | |

* | |

* Khronos Group makes no, and expressly disclaims any, representations | |

* or warranties, express or implied, regarding these materials, including, | |

* without limitation, any implied warranties of merchantability or fitness | |

* for a particular purpose or non-infringement of any intellectual property. | |

* Khronos Group makes no, and expressly disclaims any, warranties, express | |

* or implied, regarding the correctness, accuracy, completeness, timeliness, | |

* and reliability of these materials. | |

* | |

* Under no circumstances will the Khronos Group, or any of its Promoters, | |

* Contributors or Members or their respective partners, officers, directors, | |

* employees, agents or representatives be liable for any damages, whether | |

* direct, indirect, special or consequential damages for lost revenues, | |

* lost profits, or otherwise, arising from or in connection with these | |

* materials. | |

* | |

* Khronos and OpenMAX are trademarks of the Khronos Group Inc. | |

* | |

*/ | |

/* *****************************************************************************************/ | |

#ifndef _OMXSP_H_ | |

#define _OMXSP_H_ | |

#include "dl/api/omxtypes.h" | |

#ifdef __cplusplus | |

extern "C" { | |

#endif | |

/* 2.1 Vendor-Specific FFT Data Structures */ | |

typedef void OMXFFTSpec_C_SC16; | |

typedef void OMXFFTSpec_C_SC32; | |

typedef void OMXFFTSpec_R_S16S32; | |

typedef void OMXFFTSpec_R_S16; | |

typedef void OMXFFTSpec_R_S32; | |

typedef void OMXFFTSpec_R_F32; | |

typedef void OMXFFTSpec_C_FC32; | |

/** | |

* Function: omxSP_Copy_S16 (2.2.1.1.1) | |

* | |

* Description: | |

* Copies the len elements of the vector pointed to by pSrcinto the len | |

* elements of the vector pointed to by pDst. That is: | |

* pDst[i] = pSrc[i], for (i=0, 1, ..., len-1) | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the source vector | |

* len - number of elements contained in the source and destination vectors | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the destination vector | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments detected; returned if one or more of | |

* the following is true: | |

* - pSrc or pDst is NULL | |

* - len < 0 | |

* | |

*/ | |

OMXResult omxSP_Copy_S16 ( | |

const OMX_S16 *pSrc, | |

OMX_S16 *pDst, | |

OMX_INT len | |

); | |

/** | |

* Function: omxSP_DotProd_S16 (2.2.2.1.1) | |

* | |

* Description: | |

* Calculates the dot product of the two input vectors. This function does | |

* not perform scaling. The internal accumulator width must be at least 32 | |

* bits. If any of the partially accumulated values exceeds the range of a | |

* signed 32-bit integer then the result is undefined. | |

* | |

* Input Arguments: | |

* | |

* pSrc1 - pointer to the first input vector; must be aligned on an 8-byte | |

* boundary. | |

* pSrc2 - pointer to the second input vector; must be aligned on an 8-byte | |

* boundary. | |

* len - length of the vectors in pSrc1 and pSrc2 | |

* | |

* Output Arguments: | |

* | |

* Return Value: | |

* | |

* The dot product result Note: this function returns the actual result | |

* rather than the standard OMXError. | |

* | |

*/ | |

OMX_S32 omxSP_DotProd_S16 ( | |

const OMX_S16 *pSrc1, | |

const OMX_S16 *pSrc2, | |

OMX_INT len | |

); | |

/** | |

* Function: omxSP_DotProd_S16_Sfs (2.2.2.1.2) | |

* | |

* Description: | |

* Calculates the dot product of the two input signals with output scaling | |

* and saturation, i.e., the result is multiplied by two to the power of the | |

* negative (-)scalefactor (scaled) prior to return. The result is saturated | |

* with rounding if the scaling operation produces a value outside the range | |

* of a signed 32-bit integer. Rounding behavior is defined in section 1.6.7 | |

* Integer Scaling and Rounding Conventions. The internal accumulator width | |

* must be at least 32 bits. The result is undefined if any of the partially | |

* accumulated values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrc1 - pointer to the first input vector; must be aligned on an 8-byte | |

* boundary. | |

* pSrc2 - pointer to the second input vector; must be aligned on an 8-byte | |

* boundary. | |

* len - length of the vectors in pSrc1 and pSrc2 | |

* scaleFactor - integer scalefactor | |

* | |

* Output Arguments: | |

* | |

* Return Value: | |

* | |

* The dot product result Note: This function returns the actual result | |

* rather than the standard OMXError. | |

* | |

*/ | |

OMX_S32 omxSP_DotProd_S16_Sfs ( | |

const OMX_S16 *pSrc1, | |

const OMX_S16 *pSrc2, | |

OMX_INT len, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_BlockExp_S16 (2.2.2.2.2) | |

* | |

* Description: | |

* Block exponent calculation for 16-bit and 32-bit signals (count leading | |

* sign bits). These functions compute the number of extra sign bits of all | |

* values in the 16-bit and 32-bit input vector pSrc and return the minimum | |

* sign bit count. This is also the maximum shift value that could be used in | |

* scaling the block of data. The functions BlockExp_S16 and | |

* BlockExp_S32 return the values 15 and 31, respectively, for input vectors in | |

* which all entries are equal to zero. | |

* | |

* Note: These functions differ from other DL functions by not returning the | |

* standard OMXError but the actual result. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the input vector | |

* len - number of elements contained in the input and output | |

* vectors (0 < len < 65536) | |

* | |

* Output Arguments: | |

* | |

* none | |

* | |

* Return Value: | |

* | |

* Maximum exponent that may be used in scaling | |

* | |

*/ | |

OMX_INT omxSP_BlockExp_S16 ( | |

const OMX_S16 *pSrc, | |

OMX_INT len | |

); | |

/** | |

* Function: omxSP_BlockExp_S32 (2.2.2.2.2) | |

* | |

* Description: | |

* Block exponent calculation for 16-bit and 32-bit signals (count leading | |

* sign bits). These functions compute the number of extra sign bits of all | |

* values in the 16-bit and 32-bit input vector pSrc and return the minimum | |

* sign bit count. This is also the maximum shift value that could be used in | |

* scaling the block of data. The functions BlockExp_S16 and | |

* BlockExp_S32 return the values 15 and 31, respectively, for input vectors in | |

* which all entries are equal to zero. | |

* | |

* Note: These functions differ from other DL functions by not returning the | |

* standard OMXError but the actual result. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the input vector | |

* len - number of elements contained in the input and output | |

* vectors (0 < len < 65536) | |

* | |

* Output Arguments: | |

* | |

* none | |

* | |

* Return Value: | |

* | |

* Maximum exponent that may be used in scaling | |

* | |

*/ | |

OMX_INT omxSP_BlockExp_S32 ( | |

const OMX_S32 *pSrc, | |

OMX_INT len | |

); | |

/** | |

* Function: omxSP_FIR_Direct_S16 (2.2.3.1.1) | |

* | |

* Description: | |

* Block FIR filtering for 16-bit data type. This function applies the | |

* FIR filter defined by the coefficient vector pTapsQ15 to a vector of | |

* input data. The result is saturated with rounding if the operation | |

* produces a value outside the range of a signed 16-bit integer. | |

* Rounding behavior is defined in: | |

* section 1.6.7 "Integer Scaling and Rounding Conventions". | |

* The internal accumulator width must be at least 32 bits. The result | |

* is undefined if any of the partially accumulated values exceeds the | |

* range of a signed 32-bit integer. | |

* | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the vector of input samples to which the | |

* filter is applied | |

* sampLen - the number of samples contained in the input and output | |

* vectors | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k <tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pSrc, | |

* - pDst, | |

* - pSrcDst, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - samplen < 0 | |

* - tapslen < 1 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen). | |

* | |

*/ | |

OMXResult omxSP_FIR_Direct_S16 ( | |

const OMX_S16 *pSrc, | |

OMX_S16 *pDst, | |

OMX_INT sampLen, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex | |

); | |

/** | |

* Function: omxSP_FIR_Direct_S16_I (2.2.3.1.1) | |

* | |

* Description: | |

* Block FIR filtering for 16-bit data type. This function applies the | |

* FIR filter defined by the coefficient vector pTapsQ15 to a vector of | |

* input data. The result is saturated with rounding if the operation | |

* produces a value outside the range of a signed 16-bit integer. | |

* Rounding behavior is defined in: | |

* section 1.6.7 "Integer Scaling and Rounding Conventions". | |

* The internal accumulator width must be at least 32 bits. The result | |

* is undefined if any of the partially accumulated values exceeds the | |

* range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrcDst - pointer to the vector of input samples to which the | |

* filter is applied | |

* sampLen - the number of samples contained in the input and output | |

* vectors | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k <tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* | |

* Output Arguments: | |

* | |

* pSrcDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pSrc, | |

* - pDst, | |

* - pSrcDst, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - samplen < 0 | |

* - tapslen < 1 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen). | |

* | |

*/ | |

OMXResult omxSP_FIR_Direct_S16_I ( | |

OMX_S16 *pSrcDst, | |

OMX_INT sampLen, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex | |

); | |

/** | |

* Function: omxSP_FIR_Direct_S16_Sfs (2.2.3.1.1) | |

* | |

* Description: | |

* Block FIR filtering for 16-bit data type. This function applies | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a | |

* vector of input data. The output is multiplied by 2 to the negative | |

* power of scalefactor (i.e., 2^-scalefactor) before returning to the caller. | |

* Scaling and rounding conventions are defined in section 1.6.7. | |

* The internal accumulator width must be at least 32 bits. | |

* The result is undefined if any of the partially accumulated | |

* values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the vector of input samples to which the | |

* filter is applied | |

* sampLen - the number of samples contained in the input and output | |

* vectors | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k <tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* scaleFactor - saturation fixed scalefactor | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pSrc, | |

* - pDst, | |

* - pSrcDst, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - samplen < 0 | |

* - tapslen < 1 | |

* - scaleFactor < 0 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen). | |

* | |

*/ | |

OMXResult omxSP_FIR_Direct_S16_Sfs ( | |

const OMX_S16 *pSrc, | |

OMX_S16 *pDst, | |

OMX_INT sampLen, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FIR_Direct_S16_ISfs (2.2.3.1.1) | |

* | |

* Description: | |

* Block FIR filtering for 16-bit data type. This function applies | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a | |

* vector of input data. The output is multiplied by 2 to the negative | |

* power of scalefactor (i.e., 2^-scalefactor) before returning to the caller. | |

* Scaling and rounding conventions are defined in section 1.6.7. | |

* The internal accumulator width must be at least 32 bits. | |

* The result is undefined if any of the partially accumulated | |

* values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrcDst - pointer to the vector of input samples to which the | |

* filter is applied | |

* sampLen - the number of samples contained in the input and output | |

* vectors | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k <tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* scaleFactor - saturation fixed scalefactor | |

* | |

* Output Arguments: | |

* | |

* pSrcDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pSrc, | |

* - pDst, | |

* - pSrcDst, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - samplen < 0 | |

* - tapslen < 1 | |

* - scaleFactor < 0 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen). | |

* | |

*/ | |

OMXResult omxSP_FIR_Direct_S16_ISfs ( | |

OMX_S16 *pSrcDst, | |

OMX_INT sampLen, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FIROne_Direct_S16 (2.2.3.1.2) | |

* | |

* Description: | |

* Single-sample FIR filtering for 16-bit data type. These functions apply | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a single | |

* sample of input data. The result is saturated with rounding if the | |

* operation produces a value outside the range of a signed 16-bit integer. | |

* Rounding behavior is defined in: | |

* section 1.6.7 "Integer Scaling and Rounding Conventions". | |

* The internal accumulator width must be at least 32 bits. The result is | |

* undefined if any of the partially accumulated values exceeds the range of a | |

* signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* val - the single input sample to which the filter is | |

* applied. | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (as defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k < tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* | |

* Output Arguments: | |

* | |

* pResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pResult, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - tapslen < 1 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen) | |

* | |

*/ | |

OMXResult omxSP_FIROne_Direct_S16 ( | |

OMX_S16 val, | |

OMX_S16 *pResult, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex | |

); | |

/** | |

* Function: omxSP_FIROne_Direct_S16_I (2.2.3.1.2) | |

* | |

* Description: | |

* Single-sample FIR filtering for 16-bit data type. These functions apply | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a single | |

* sample of input data. The result is saturated with rounding if the | |

* operation produces a value outside the range of a signed 16-bit integer. | |

* Rounding behavior is defined in: | |

* section 1.6.7 "Integer Scaling and Rounding Conventions". | |

* The internal accumulator width must be at least 32 bits. The result is | |

* undefined if any of the partially accumulated values exceeds the range of a | |

* signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pValResult - pointer to the single input sample to which the filter is | |

* applied. | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (as defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k < tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* | |

* Output Arguments: | |

* | |

* pValResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pValResult, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - tapslen < 1 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen) | |

* | |

*/ | |

OMXResult omxSP_FIROne_Direct_S16_I ( | |

OMX_S16 *pValResult, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex | |

); | |

/** | |

* Function: omxSP_FIROne_Direct_S16_Sfs (2.2.3.1.2) | |

* | |

* Description: | |

* Single-sample FIR filtering for 16-bit data type. These functions apply | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a single | |

* sample of input data. The output is multiplied by 2 to the negative power | |

* of scalefactor (i.e., 2^-scalefactor) before returning to the user. | |

* Scaling and rounding conventions are defined in section 1.6.7. | |

* The internal accumulator width must be at least 32 bits. | |

* The result is undefined if any of the partially accumulated values exceeds | |

* the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* val - the single input sample to which the filter is | |

* applied. | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (as defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k < tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* scaleFactor - saturation fixed scaleFactor | |

* | |

* Output Arguments: | |

* | |

* pResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pResult, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - tapslen < 1 | |

* - scaleFactor < 0 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen) | |

* | |

*/ | |

OMXResult omxSP_FIROne_Direct_S16_Sfs ( | |

OMX_S16 val, | |

OMX_S16 *pResult, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FIROne_Direct_S16_ISfs (2.2.3.1.2) | |

* | |

* Description: | |

* Single-sample FIR filtering for 16-bit data type. These functions apply | |

* the FIR filter defined by the coefficient vector pTapsQ15 to a single | |

* sample of input data. The output is multiplied by 2 to the negative power | |

* of scalefactor (i.e., 2^-scalefactor) before returning to the user. | |

* Scaling and rounding conventions are defined in section 1.6.7. | |

* The internal accumulator width must be at least 32 bits. | |

* The result is undefined if any of the partially accumulated values exceeds | |

* the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pValResult - the pointer to a single input sample to which the filter is | |

* applied. | |

* pTapsQ15 - pointer to the vector that contains the filter coefficients, | |

* represented in Q0.15 format (as defined in section 1.6.5). Given | |

* that: | |

* -32768 = pTapsQ15(k) < 32768, | |

* 0 = k < tapsLen, | |

* the range on the actual filter coefficients is -1 = bK <1, and | |

* therefore coefficient normalization may be required during the | |

* filter design process. | |

* tapsLen - the number of taps, or, equivalently, the filter order + 1 | |

* pDelayLine - pointer to the 2.tapsLen -element filter memory buffer | |

* (state). The user is responsible for allocation, initialization, | |

* and de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* pDelayLineIndex - pointer to the filter memory index that is maintained | |

* internally by the function. The user should initialize the value | |

* of this index to zero. | |

* scaleFactor - saturation fixed scaleFactor | |

* | |

* Output Arguments: | |

* | |

* pValResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - One or more of the following pointers is NULL: | |

* - pValResult, | |

* - pTapsQ15, | |

* - pDelayLine, or | |

* - pDelayLineIndex | |

* - tapslen < 1 | |

* - scaleFactor < 0 | |

* - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen) | |

* | |

*/ | |

OMXResult omxSP_FIROne_Direct_S16_ISfs ( | |

OMX_S16 *pValResult, | |

const OMX_S16 *pTapsQ15, | |

OMX_INT tapsLen, | |

OMX_S16 *pDelayLine, | |

OMX_INT *pDelayLineIndex, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_IIR_Direct_S16 (2.2.3.2.1) | |

* | |

* Description: | |

* Block IIR filtering for 16-bit data. This function applies the direct form | |

* II IIR filter defined by the coefficient vector pTaps to a vector of input | |

* data. The internal accumulator width must be at least 32 bits, and the | |

* result is saturated if the operation produces a value outside the range of | |

* a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768) | |

* for a negative overflow or 0x7fff (32767) for a positive overflow. The | |

* result is undefined if any of the partially accumulated values exceeds the | |

* range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the vector of input samples to which the | |

* filter is applied | |

* len - the number of samples contained in both the input and output | |

* vectors | |

* pTaps - pointer to the 2L+2-element vector that contains the combined | |

* numerator and denominator filter coefficients from the system | |

* transfer function, H(z). Coefficient scaling and coefficient | |

* vector organization should follow the conventions described | |

* above. The value of the coefficient scaleFactor exponent must be | |

* non-negative (sf=0). | |

* order - the maximum of the degrees of the numerator and denominator | |

* coefficient polynomials from the system transfer function, H(z). | |

* In the notation of section 2.2.3.2, the parameter | |

* order=max(K,M)=L gives the maximum delay, in samples, used to | |

* compute each output sample. | |

* pDelayLine - pointer to the L-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: | |

* - pSrc, | |

* - pDst, | |

* - pTaps, or | |

* - pDelayLine. | |

* - len < 0 | |

* - pTaps[order+1] < 0 (negative scaling) | |

* - order < 1 | |

* | |

*/ | |

OMXResult omxSP_IIR_Direct_S16 ( | |

const OMX_S16 *pSrc, | |

OMX_S16 *pDst, | |

OMX_INT len, | |

const OMX_S16 *pTaps, | |

OMX_INT order, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIR_Direct_S16_I (2.2.3.2.1) | |

* | |

* Description: | |

* Block IIR filtering for 16-bit data. This function applies the direct form | |

* II IIR filter defined by the coefficient vector pTaps to a vector of input | |

* data. The internal accumulator width must be at least 32 bits, and the | |

* result is saturated if the operation produces a value outside the range of | |

* a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768) | |

* for a negative overflow or 0x7fff (32767) for a positive overflow. The | |

* result is undefined if any of the partially accumulated values exceeds the | |

* range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrcDst - pointer to the vector of input samples to which the | |

* filter is applied | |

* len - the number of samples contained in both the input and output | |

* vectors | |

* pTaps - pointer to the 2L+2-element vector that contains the combined | |

* numerator and denominator filter coefficients from the system | |

* transfer function, H(z). Coefficient scaling and coefficient | |

* vector organization should follow the conventions described | |

* above. The value of the coefficient scaleFactor exponent must be | |

* non-negative (sf>=0). | |

* order - the maximum of the degrees of the numerator and denominator | |

* coefficient polynomials from the system transfer function, H(z). | |

* In the notation of section 2.2.3.2, the parameter | |

* order=max(K,M)=L gives the maximum delay, in samples, used to | |

* compute each output sample. | |

* pDelayLine - pointer to the L-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pSrcDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: | |

* - pSrcDst, | |

* - pTaps, or | |

* - pDelayLine. | |

* - len < 0 | |

* - pTaps[order+1] < 0 (negative scaling) | |

* - order < 1 | |

* | |

*/ | |

OMXResult omxSP_IIR_Direct_S16_I ( | |

OMX_S16 *pSrcDst, | |

OMX_INT len, | |

const OMX_S16 *pTaps, | |

OMX_INT order, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIROne_Direct_S16 (2.2.3.2.2) | |

* | |

* Description: | |

* Single sample IIR filtering for 16-bit data. This function applies the | |

* direct form II IIR filter defined by the coefficient vector pTaps to a | |

* single sample of input data. The internal accumulator width must be at | |

* least 32 bits, and the result is saturated if the operation produces a | |

* value outside the range of a signed 16-bit integer, i.e., the output will | |

* saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a | |

* positive overflow. The result is undefined if any of the partially | |

* accumulated values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* val - the single input sample to which the filter is | |

* applied. | |

* pTaps - pointer to the 2L+2 -element vector that contains the combined | |

* numerator and denominator filter coefficients from the system | |

* transfer function, H(z). Coefficient scaling and coefficient | |

* vector organization should follow the conventions described | |

* above. The value of the coefficient scaleFactor exponent must be | |

* non-negative (sf>=0). | |

* order - the maximum of the degrees of the numerator and denominator | |

* coefficient polynomials from the system transfer function, H(z). | |

* In the notation of section 2.2.3.2, the parameter | |

* order=max(K,M)=L gives the maximum delay, in samples, used to | |

* compute each output sample. | |

* pDelayLine - pointer to the L-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: pResult, | |

* pTaps, or pDelayLine. | |

* - order < 1 | |

* - pTaps[order+1] < 0 (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIROne_Direct_S16 ( | |

OMX_S16 val, | |

OMX_S16 *pResult, | |

const OMX_S16 *pTaps, | |

OMX_INT order, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIROne_Direct_S16_I (2.2.3.2.2) | |

* | |

* Description: | |

* Single sample IIR filtering for 16-bit data. This function applies the | |

* direct form II IIR filter defined by the coefficient vector pTaps to a | |

* single sample of input data. The internal accumulator width must be at | |

* least 32 bits, and the result is saturated if the operation produces a | |

* value outside the range of a signed 16-bit integer, i.e., the output will | |

* saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a | |

* positive overflow. The result is undefined if any of the partially | |

* accumulated values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pValResult - pointer to the single input sample to which the filter is | |

* applied. | |

* pTaps - pointer to the 2L+2 -element vector that contains the combined | |

* numerator and denominator filter coefficients from the system | |

* transfer function, H(z). Coefficient scaling and coefficient | |

* vector organization should follow the conventions described | |

* above. The value of the coefficient scaleFactor exponent must be | |

* non-negative (sf>=0). | |

* order - the maximum of the degrees of the numerator and denominator | |

* coefficient polynomials from the system transfer function, H(z). | |

* In the notation of section 2.2.3.2, the parameter | |

* order=max(K,M)=L gives the maximum delay, in samples, used to | |

* compute each output sample. | |

* pDelayLine - pointer to the L-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pValResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: | |

* pValResult, pTaps, or pDelayLine. | |

* - order < 1 | |

* - pTaps[order+1] < 0 (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIROne_Direct_S16_I ( | |

OMX_S16 *pValResult, | |

const OMX_S16 *pTaps, | |

OMX_INT order, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIR_BiQuadDirect_S16 (2.2.3.3.1) | |

* | |

* Description: | |

* Block biquad IIR filtering for 16-bit data type. This function applies the | |

* direct form II biquad IIR cascade defined by the coefficient vector pTaps | |

* to a vector of input data. The internal accumulator width must be at least | |

* 32 bits, and the result is saturated if the operation produces a value | |

* outside the range of a signed 16-bit integer, i.e., the output will | |

* saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a | |

* positive overflow. The result is undefined if any of the partially | |

* accumulated values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the vector of input samples to which the | |

* filter is applied | |

* len - the number of samples contained in both the input and output | |

* vectors | |

* pTaps - pointer to the 6P -element vector that contains the combined | |

* numerator and denominator filter coefficients from the biquad | |

* cascade. Coefficient scaling and coefficient vector organization | |

* should follow the conventions described above. The value of the | |

* coefficient scaleFactor exponent must be non-negative. (sfp>=0). | |

* numBiquad - the number of biquads contained in the IIR filter cascade: | |

* (P) | |

* pDelayLine - pointer to the 2P -element filter memory buffer (state). | |

* The user is responsible for allocation, initialization, and | |

* de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, | |

* pTaps, or pDelayLine. | |

* - len < 0 | |

* - numBiquad < 1 | |

* - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIR_BiQuadDirect_S16 ( | |

const OMX_S16 *pSrc, | |

OMX_S16 *pDst, | |

OMX_INT len, | |

const OMX_S16 *pTaps, | |

OMX_INT numBiquad, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIR_BiQuadDirect_S16_I (2.2.3.3.1) | |

* | |

* Description: | |

* Block biquad IIR filtering for 16-bit data type. This function applies the | |

* direct form II biquad IIR cascade defined by the coefficient vector pTaps | |

* to a vector of input data. The internal accumulator width must be at least | |

* 32 bits, and the result is saturated if the operation produces a value | |

* outside the range of a signed 16-bit integer, i.e., the output will | |

* saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a | |

* positive overflow. The result is undefined if any of the partially | |

* accumulated values exceeds the range of a signed 32-bit integer. | |

* | |

* Input Arguments: | |

* | |

* pSrcDst - pointer to the vector of input samples to which the | |

* filter is applied | |

* len - the number of samples contained in both the input and output | |

* vectors | |

* pTaps - pointer to the 6P -element vector that contains the combined | |

* numerator and denominator filter coefficients from the biquad | |

* cascade. Coefficient scaling and coefficient vector organization | |

* should follow the conventions described above. The value of the | |

* coefficient scaleFactor exponent must be non-negative. (sfp>=0). | |

* numBiquad - the number of biquads contained in the IIR filter cascade: | |

* (P) | |

* pDelayLine - pointer to the 2P -element filter memory buffer (state). | |

* The user is responsible for allocation, initialization, and | |

* de-allocation. The filter memory elements are initialized to | |

* zero in most applications. | |

* | |

* Output Arguments: | |

* | |

* pSrcDst - pointer to the vector of filtered output samples | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: | |

* pSrcDst, pTaps, or pDelayLine. | |

* - len < 0 | |

* - numBiquad < 1 | |

* - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIR_BiQuadDirect_S16_I ( | |

OMX_S16 *pSrcDst, | |

OMX_INT len, | |

const OMX_S16 *pTaps, | |

OMX_INT numBiquad, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIROne_BiQuadDirect_S16 (2.2.3.3.2) | |

* | |

* Description: | |

* Single-sample biquad IIR filtering for 16-bit data type. This function | |

* applies the direct form II biquad IIR cascade defined by the coefficient | |

* vector pTaps to a single sample of input data. The internal accumulator | |

* width must be at least 32 bits, and the result is saturated if the | |

* operation produces a value outside the range of a signed 16-bit integer, | |

* i.e., the output will saturate to 0x8000 (-32768) for a negative overflow | |

* or 0x7fff (32767) for a positive overflow. The result is undefined if any | |

* of the partially accumulated values exceeds the range of a signed 32-bit | |

* integer. | |

* | |

* Input Arguments: | |

* | |

* val - the single input sample to which the filter is | |

* applied. | |

* pTaps - pointer to the 6P-element vector that contains the combined | |

* numerator and denominator filter coefficients from the biquad | |

* cascade. Coefficient scaling and coefficient vector organization | |

* should follow the conventions described above. The value of the | |

* coefficient scalefactor exponent must be non-negative: (sfp>=0). | |

* numBiquad - the number of biquads contained in the IIR filter cascade: | |

* (P) | |

* pDelayLine - pointer to the 2p-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: pResult, | |

* pValResult, pTaps, or pDelayLine. | |

* - numBiquad < 1 | |

* - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIROne_BiQuadDirect_S16 ( | |

OMX_S16 val, | |

OMX_S16 *pResult, | |

const OMX_S16 *pTaps, | |

OMX_INT numBiquad, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_IIROne_BiQuadDirect_S16_I (2.2.3.3.2) | |

* | |

* Description: | |

* Single-sample biquad IIR filtering for 16-bit data type. This function | |

* applies the direct form II biquad IIR cascade defined by the coefficient | |

* vector pTaps to a single sample of input data. The internal accumulator | |

* width must be at least 32 bits, and the result is saturated if the | |

* operation produces a value outside the range of a signed 16-bit integer, | |

* i.e., the output will saturate to 0x8000 (-32768) for a negative overflow | |

* or 0x7fff (32767) for a positive overflow. The result is undefined if any | |

* of the partially accumulated values exceeds the range of a signed 32-bit | |

* integer. | |

* | |

* Input Arguments: | |

* | |

* pValResult - pointer to the single input sample to which the filter is | |

* applied. | |

* pTaps - pointer to the 6P-element vector that contains the combined | |

* numerator and denominator filter coefficients from the biquad | |

* cascade. Coefficient scaling and coefficient vector organization | |

* should follow the conventions described above. The value of the | |

* coefficient scalefactor exponent must be non-negative: (sfp>=0). | |

* numBiquad - the number of biquads contained in the IIR filter cascade: | |

* (P) | |

* pDelayLine - pointer to the 2p-element filter memory buffer (state). The | |

* user is responsible for allocation, initialization, and | |

* deallocation. The filter memory elements are initialized to zero | |

* in most applications. | |

* | |

* Output Arguments: | |

* | |

* pValResult - pointer to the filtered output sample | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: | |

* pValResult, pTaps, or pDelayLine. | |

* - numBiquad < 1 | |

* - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling) | |

* | |

*/ | |

OMXResult omxSP_IIROne_BiQuadDirect_S16_I ( | |

OMX_S16 *pValResult, | |

const OMX_S16 *pTaps, | |

OMX_INT numBiquad, | |

OMX_S32 *pDelayLine | |

); | |

/** | |

* Function: omxSP_FilterMedian_S32 (2.2.3.4.1) | |

* | |

* Description: | |

* This function computes the median over the region specified by the median | |

* mask for the every element of the input array. The median outputs are | |

* stored in the corresponding elements of the output vector. | |

* | |

* Input Arguments: | |

* | |

* pSrc - pointer to the input vector | |

* len - number of elements contained in the input and output vectors (0 < | |

* len < 65536) | |

* maskSize - median mask size; if an even value is specified, the function | |

* subtracts 1 and uses the odd value of the filter mask for median | |

* filtering (0 < maskSize < 256) | |

* | |

* Output Arguments: | |

* | |

* pDst - pointer to the median-filtered output vector | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst. | |

* - len < 0 | |

* - maskSize < 1 or maskSize> 255 | |

* OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask | |

* size | |

* | |

*/ | |

OMXResult omxSP_FilterMedian_S32 ( | |

const OMX_S32 *pSrc, | |

OMX_S32 *pDst, | |

OMX_INT len, | |

OMX_INT maskSize | |

); | |

/** | |

* Function: omxSP_FilterMedian_S32_I (2.2.3.4.1) | |

* | |

* Description: | |

* This function computes the median over the region specified by the median | |

* mask for the every element of the input array. The median outputs are | |

* stored in the corresponding elements of the output vector. | |

* | |

* Input Arguments: | |

* | |

* pSrcDst - pointer to the input vector | |

* len - number of elements contained in the input and output vectors (0 < | |

* len < 65536) | |

* maskSize - median mask size; if an even value is specified, the function | |

* subtracts 1 and uses the odd value of the filter mask for median | |

* filtering (0 < maskSize < 256) | |

* | |

* Output Arguments: | |

* | |

* pSrcDst - pointer to the median-filtered output vector | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pSrcDst is NULL. | |

* - len < 0 | |

* - maskSize < 1 or maskSize> 255 | |

* OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask | |

* size | |

* | |

*/ | |

OMXResult omxSP_FilterMedian_S32_I ( | |

OMX_S32 *pSrcDst, | |

OMX_INT len, | |

OMX_INT maskSize | |

); | |

/** | |

* Function: omxSP_FFTInit_C_SC16 (2.2.4.1.2) | |

* | |

* Description: | |

* These functions initialize the specification structures required for the | |

* complex FFT and IFFT functions. Desired block length is specified as an | |

* input. The function <FFTInit_C_SC16> is used to initialize the | |

* specification structures for functions <FFTFwd_CToC_SC16_Sfs> and | |

* <FFTInv_CToC_SC16_Sfs>. | |

* | |

* Memory for the specification structure *pFFTSpec | |

* must be allocated prior to calling these functions and should be 4-byte | |

* aligned for omxSP_FFTInit_C_SC16. | |

* | |

* The space required for *pFFTSpec, in bytes, can be | |

* determined using <FFTGetBufSize_C_SC16>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; | |

* valid in the range [0,12] | |

* | |

* Output Arguments: | |

* | |

* pFFTSpec - pointer to initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr -no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTSpec is either NULL or violates the 4-byte alignment | |

* restrictions | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_C_SC16 ( | |

OMXFFTSpec_C_SC16 *pFFTSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_C_SC32 (2.2.4.1.2) | |

* | |

* Description: | |

* These functions initialize the specification structures required for the | |

* complex FFT and IFFT functions. Desired block length is specified as an | |

* input. The function <FFTInit_C_SC32> is used to initialize | |

* the specification structures for the functions <FFTFwd_CToC_SC32_Sfs> and | |

* <FFTInv_CToC_SC32_Sfs>. | |

* | |

* Memory for the specification structure *pFFTSpec must be allocated prior | |

* to calling these functions and should be 8-byte aligned for | |

* omxSP_FFTInit_C_SC32. | |

* | |

* The space required for *pFFTSpec, in bytes, can be | |

* determined using <FFTGetBufSize_C_SC32>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [0,12] | |

* | |

* Output Arguments: | |

* | |

* pFFTSpec - pointer to initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr -no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_C_SC32 ( | |

OMXFFTSpec_C_SC32 *pFFTSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_C_FC32 (2.2.4.1.2) | |

* | |

* Description: | |

* These functions initialize the specification structures required for the | |

* complex FFT and IFFT functions. Desired block length is specified as an | |

* input. The function <FFTInit_C_FC32> is used to initialize | |

* the specification structures for the functions <FFTFwd_CToC_FC32_Sfs> and | |

* <FFTInv_CToC_FC32_Sfs>. | |

* | |

* Memory for the specification structure *pFFTSpec must be allocated prior | |

* to calling these functions and should be 8-byte aligned for | |

* omxSP_FFTInit_C_FC32. | |

* | |

* The space required for *pFFTSpec, in bytes, can be | |

* determined using <FFTGetBufSize_C_FC32>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [1,15] | |

* | |

* Output Arguments: | |

* | |

* pFFTSpec - pointer to initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr -no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 1 or order > 15 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_C_FC32( | |

OMXFFTSpec_C_FC32* pFFTSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_R_S16S32 (2.2.4.1.4) | |

* | |

* Description: | |

* These functions initialize specification structures required for the real | |

* FFT and IFFT functions. The function <FFTInit_R_S16S32> is used to | |

* initialize the specification structures for functions | |

* <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>. | |

* | |

* Memory for | |

* *pFFTFwdSpec must be allocated before calling these functions and should be | |

* 8-byte aligned. The number of bytes required for *pFFTFwdSpec can be | |

* determined using <FFTGetBufSize_R_S16S32>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [0,12] | |

* | |

* Output Arguments: | |

* | |

* pFFTFwdSpec - pointer to the initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTFwdSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_R_S16S32( | |

OMXFFTSpec_R_S16S32* pFFTFwdSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_R_S16 | |

* | |

* Description: | |

* These functions initialize specification structures required for the real | |

* FFT and IFFT functions. The function <FFTInit_R_S16> is used | |

* to initialize the specification structures for functions | |

* <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>. | |

* | |

* Memory for *pFFTFwdSpec must be allocated before calling these functions | |

* and should be 8-byte aligned. | |

* | |

* The number of bytes required for *pFFTFwdSpec can be | |

* determined using <FFTGetBufSize_R_S16>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [1,12] | |

* | |

* Output Arguments: | |

* | |

* pFFTFwdSpec - pointer to the initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTFwdSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 1 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_R_S16 ( | |

OMXFFTSpec_R_S32*pFFTFwdSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_R_S32 (2.2.4.1.4) | |

* | |

* Description: | |

* These functions initialize specification structures required for the real | |

* FFT and IFFT functions. The function <FFTInit_R_S32> is used to initialize | |

* the specification structures for functions <FFTFwd_RToCCS_S32_Sfs> | |

* and <FFTInv_CCSToR_S32_Sfs>. | |

* | |

* Memory for *pFFTFwdSpec must be allocated before calling these functions | |

* and should be 8-byte aligned. | |

* | |

* The number of bytes required for *pFFTFwdSpec can be | |

* determined using <FFTGetBufSize_R_S32>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [0,12] | |

* | |

* Output Arguments: | |

* | |

* pFFTFwdSpec - pointer to the initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTFwdSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_R_S32 ( | |

OMXFFTSpec_R_S32*pFFTFwdSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTInit_R_F32 | |

* | |

* Description: | |

* These functions initialize specification structures required for the real | |

* FFT and IFFT functions. The function <FFTInit_R_F32> is used to initialize | |

* the specification structures for functions <FFTFwd_RToCCS_F32_Sfs> | |

* and <FFTInv_CCSToR_F32_Sfs>. | |

* | |

* Memory for *pFFTFwdSpec must be allocated before calling these functions | |

* and should be 8-byte aligned. | |

* | |

* The number of bytes required for *pFFTFwdSpec can be | |

* determined using <FFTGetBufSize_R_F32>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [1,15] | |

* | |

* Output Arguments: | |

* | |

* pFFTFwdSpec - pointer to the initialized specification structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pFFTFwdSpec is either NULL or violates the 8-byte alignment | |

* restrictions | |

* - order < 1 or order > 15 | |

* | |

*/ | |

OMXResult omxSP_FFTInit_R_F32( | |

OMXFFTSpec_R_F32* pFFTFwdSpec, | |

OMX_INT order | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_C_SC16 (2.2.4.1.6) | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order complex FFT and IFFT functions. The function | |

* <FFTGetBufSize_C_SC16> is used in conjunction with the 16-bit functions | |

* <FFTFwd_CToC_SC16_Sfs> and <FFTInv_CToC_SC16_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [0,12] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pSize is NULL | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_C_SC16 ( | |

OMX_INT order, | |

OMX_INT *pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_C_SC32 (2.2.4.1.6) | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order complex FFT and IFFT functions. The function | |

* <FFTGetBufSize_C_SC32> is used in conjunction with the 32-bit functions | |

* <FFTFwd_CToC_SC32_Sfs> and <FFTInv_CToC_SC32_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [0,12] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pSize is NULL | |

* - order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_C_SC32 ( | |

OMX_INT order, | |

OMX_INT *pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_C_FC32 | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order complex FFT and IFFT functions. The function | |

* <FFTGetBufSize_C_FC32> is used in conjunction with the 32-bit functions | |

* <FFTFwd_CToC_FC32_Sfs> and <FFTInv_CToC_FC32_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the desired block length; valid in the range | |

* [1,15] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments; returned if one or more of the | |

* following is true: | |

* - pSize is NULL | |

* - order < 1 or order > 15 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_C_FC32( | |

OMX_INT order, | |

OMX_INT* pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_R_S16S32 (2.2.4.1.8) | |

* | |

* Description: | |

* order These functions compute the size of the specification structure | |

* required for the length 2^order real FFT and IFFT functions. The function | |

* <FFTGetBufSize_R_S16S32> is used in conjunction with the 16-bit functions | |

* <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the length; valid in the range [0,12] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments The function returns | |

* OMX_Sts_BadArgErr if one or more of the following is true: | |

* pSize is NULL | |

* order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_R_S16S32( | |

OMX_INT order, | |

OMX_INT* pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_R_S16 | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order real FFT and IFFT functions. The function | |

* <FFTGetBufSize_R_S16> is used in conjunction with the 16-bit | |

* functions <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the length; valid in the range | |

* [1,12] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments The function returns | |

* OMX_Sts_BadArgErr if one or more of the following is true: | |

* pSize is NULL | |

* order < 1 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_R_S16 ( | |

OMX_INT order, | |

OMX_INT *pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_R_S32 (2.2.4.1.8) | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order real FFT and IFFT functions. The function | |

* <FFTGetBufSize_R_S32> is used in conjunction with the 32-bit functions | |

* <FFTFwd_RToCCS_S32_Sfs> and <FFTInv_CCSToR_S32_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the length; valid in the range [0,12] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments The function returns | |

* OMX_Sts_BadArgErr if one or more of the following is true: | |

* pSize is NULL | |

* order < 0 or order > 12 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_R_S32 ( | |

OMX_INT order, | |

OMX_INT *pSize | |

); | |

/** | |

* Function: omxSP_FFTGetBufSize_R_F32 | |

* | |

* Description: | |

* These functions compute the size of the specification structure | |

* required for the length 2^order real FFT and IFFT functions. The function | |

* <FFTGetBufSize_R_F32> is used in conjunction with the 32-bit functions | |

* <FFTFwd_RToCCS_F32_Sfs> and <FFTInv_CCSToR_F32_Sfs>. | |

* | |

* Input Arguments: | |

* | |

* order - base-2 logarithm of the length; valid in the range [1,15] | |

* | |

* Output Arguments: | |

* | |

* pSize - pointer to the number of bytes required for the specification | |

* structure | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments The function returns | |

* OMX_Sts_BadArgErr if one or more of the following is true: | |

* pSize is NULL | |

* order < 1 or order > 15 | |

* | |

*/ | |

OMXResult omxSP_FFTGetBufSize_R_F32( | |

OMX_INT order, | |

OMX_INT* pSize | |

); | |

/** | |

* Function: omxSP_FFTFwd_CToC_SC16_Sfs (2.2.4.2.2) | |

* | |

* Description: | |

* Compute an FFT for a complex signal of length of 2^order, | |

* where 0 <= order <= 12. | |

* Transform length is determined by the specification structure, which | |

* must be initialized prior to calling the FFT function using the appropriate | |

* helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship | |

* between the input and output sequences can be expressed in terms of the | |

* DFT, i.e., | |

* | |

* X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N) | |

* k = 0,1,2,..., N-1 | |

* N = 2^order | |

* | |

* Input Arguments: | |

* pSrc - pointer to the input signal, a complex-valued vector of length 2^order; | |

* must be aligned on a 32 byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scale factor; the range for is [0,16] | |

* | |

* Output Arguments: | |

* pDst - pointer to the complex-valued output vector, of length 2^order; | |

* must be aligned on an 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor>16 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_CToC_SC16_Sfs ( | |

const OMX_SC16 *pSrc, | |

OMX_SC16 *pDst, | |

const OMXFFTSpec_C_SC16 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

OMXResult omxSP_FFTFwd_CToC_SC16_Sfs_neon ( | |

const OMX_SC16 *pSrc, | |

OMX_SC16 *pDst, | |

const OMXFFTSpec_C_SC16 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTFwd_CToC_SC32_Sfs (2.2.4.2.2) | |

* | |

* Description: | |

* Compute an FFT for a complex signal of length of 2^order, | |

* where 0 <= order <= 12. | |

* Transform length is determined by the specification structure, which | |

* must be initialized prior to calling the FFT function using the appropriate | |

* helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship | |

* between the input and output sequences can be expressed in terms of the | |

* DFT, i.e., | |

* | |

* X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N) | |

* k = 0,1,2,..., N-1 | |

* N = 2^order | |

* | |

* Input Arguments: | |

* pSrc - pointer to the input signal, a complex-valued vector of length 2^order; | |

* must be aligned on a 32 byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scale factor; the range is [0,32] | |

* | |

* Output Arguments: | |

* pDst - pointer to the complex-valued output vector, of length 2^order; must be | |

* aligned on an 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_CToC_SC32_Sfs ( | |

const OMX_SC32 *pSrc, | |

OMX_SC32 *pDst, | |

const OMXFFTSpec_C_SC32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTInv_CToC_SC16_Sfs (2.2.4.2.4) | |

* | |

* Description: | |

* These functions compute an inverse FFT for a complex signal of length | |

* of 2^order, where 0 <= order <= 12. Transform length is determined by the | |

* specification structure, which must be initialized prior to calling the FFT | |

* function using the appropriate helper, i.e., <FFTInit_C_sc32> or | |

* <FFTInit_C_SC16>. The relationship between the input and output sequences | |

* can be expressed in terms of the IDFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input signal, of length 2^order ; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - scale factor of the output. Valid range is [0,16]. | |

* | |

* Output Arguments: | |

* order | |

* pDst - pointer to the complex-valued output signal, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* Positive value - the shift scale that was performed inside | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor>16 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CToC_SC16_Sfs ( | |

const OMX_SC16 *pSrc, | |

OMX_SC16 *pDst, | |

const OMXFFTSpec_C_SC16 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

OMXResult omxSP_FFTInv_CToC_SC16_Sfs_neon ( | |

const OMX_SC16 *pSrc, | |

OMX_SC16 *pDst, | |

const OMXFFTSpec_C_SC16 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTInv_CToC_SC32_Sfs (2.2.4.2.4) | |

* | |

* Description: | |

* These functions compute an inverse FFT for a complex signal of length | |

* of 2^order, where 0 <= order <= 12. Transform length is determined by the | |

* specification structure, which must be initialized prior to calling the FFT | |

* function using the appropriate helper, i.e., <FFTInit_C_sc32> or | |

* <FFTInit_C_SC16>. The relationship between the input and output sequences | |

* can be expressed in terms of the IDFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input signal, of length 2^order ; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - scale factor of the output. Valid range is [0,32]. | |

* | |

* Output Arguments: | |

* order | |

* pDst - pointer to the complex-valued output signal, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor>32 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CToC_SC32_Sfs ( | |

const OMX_SC32 *pSrc, | |

OMX_SC32 *pDst, | |

const OMXFFTSpec_C_SC32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTFwd_RToCCS_S16S32_Sfs (2.2.4.4.2) | |

* | |

* Description: | |

* These functions compute an FFT for a real-valued signal of length of 2^order, | |

* where 0 <= order <= 12. Transform length is determined by the | |

* specification structure, which must be initialized prior to calling the FFT | |

* function using the appropriate helper, i.e., <FFTInit_R_S16S32>. | |

* The relationship between the input and output sequences | |

* can be expressed in terms of the DFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* The conjugate-symmetric output sequence is represented using a CCS vector, | |

* which is of length N+2, and is organized as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . N-2 N-1 N N+1 | |

* Component: R0 0 R1 I1 R2 I2 . . . R[N/2-1] I[N/2-1] R[N/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components | |

* for FFT bin 'n'. Bins are numbered from 0 to N/2, where N is the FFT length. | |

* Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the | |

* foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the real-valued input sequence, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scale factor; valid range is [0, 32] | |

* | |

* Output Arguments: | |

* pDst - pointer to output sequence, represented using CCS format, of | |

* length (2^order)+2; must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true: | |

* - one of the pointers pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_RToCCS_S16S32_Sfs ( | |

const OMX_S16 *pSrc, | |

OMX_S32 *pDst, | |

const OMXFFTSpec_R_S16S32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTFwd_RToCCS_S16_Sfs | |

* | |

* Description: | |

* These functions compute an FFT for a real-valued signal of length of 2^order, | |

* where 0 < order <= 12. Transform length is determined by the | |

* specification structure, which must be initialized prior to calling the FFT | |

* function using the appropriate helper, i.e., <FFTInit_R_S16>. | |

* The relationship between the input and output sequences can | |

* be expressed in terms of the DFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* The conjugate-symmetric output sequence is represented using a CCS vector, | |

* which is of length N+2, and is organized as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . N-2 N-1 N N+1 | |

* Component: R0 0 R1 I1 R2 I2 . . . R[N/2-1] I[N/2-1] R[N/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components | |

* for FFT bin 'n'. Bins are numbered from 0 to N/2, where N is the FFT length. | |

* Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to | |

* the foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the real-valued input sequence, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scale factor; valid range is [0, 16] | |

* | |

* Output Arguments: | |

* pDst - pointer to output sequence, represented using CCS format, of | |

* length (2^order)+2; must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments, if one or more of followings is true: | |

* - one of the pointers pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >16 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_RToCCS_S16_Sfs ( | |

const OMX_S16* pSrc, | |

OMX_S16* pDst, | |

const OMXFFTSpec_R_S16* pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTFwd_RToCCS_S32_Sfs (2.2.4.4.2) | |

* | |

* Description: | |

* These functions compute an FFT for a real-valued signal of length of 2^order, | |

* where 0 <= order <= 12. Transform length is determined by the | |

* specification structure, which must be initialized prior to calling the FFT | |

* function using the appropriate helper, i.e., <FFTInit_R_S32>. | |

* The relationship between the input and output sequences | |

* can be expressed in terms of the DFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* The conjugate-symmetric output sequence is represented using a CCS vector, | |

* which is of length N+2, and is organized as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . N-2 N-1 N N+1 | |

* Component: R0 0 R1 I1 R2 I2 . . . R[N/2-1] I[N/2-1] R[N/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components | |

* for FFT bin 'n'. Bins are numbered from 0 to N/2, where N is the FFT length. | |

* Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the | |

* foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the real-valued input sequence, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scale factor; valid range is [0, 32] | |

* | |

* Output Arguments: | |

* pDst - pointer to output sequence, represented using CCS format, of | |

* length (2^order)+2; must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true: | |

* - one of the pointers pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_RToCCS_S32_Sfs ( | |

const OMX_S32 *pSrc, | |

OMX_S32 *pDst, | |

const OMXFFTSpec_R_S32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTFwd_CToC_FC32_Sfs (2.2.4.2.2) | |

* | |

* Description: | |

* Compute an FFT for a complex signal of length of 2^order, | |

* where 0 <= order <= 15. | |

* Transform length is determined by the specification structure, which | |

* must be initialized prior to calling the FFT function using the appropriate | |

* helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship | |

* between the input and output sequences can be expressed in terms of the | |

* DFT, i.e., | |

* | |

* X[k] = SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N) | |

* k = 0,1,2,..., N-1 | |

* N = 2^order | |

* | |

* Input Arguments: | |

* pSrc - pointer to the input signal, a complex-valued vector of length | |

* 2^order; must be aligned on a 32 byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* | |

* Output Arguments: | |

* pDst - pointer to the complex-valued output vector, of length 2^order; | |

* must be aligned on an 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_CToC_FC32_Sfs ( | |

const OMX_FC32 *pSrc, | |

OMX_FC32 *pDst, | |

const OMXFFTSpec_C_FC32 *pFFTSpec | |

); | |

/** | |

* Function: omxSP_FFTFwd_RToCCS_F32_Sfs | |

* | |

* Description: | |

* These functions compute an FFT for a real-valued signal of length | |

* of 2^order, where 0 <= order <= 12. Transform length is determined | |

* by the specification structure, which must be initialized prior to | |

* calling the FFT function using the appropriate helper, i.e., | |

* <FFTInit_R_F32>. The relationship between the input and output | |

* sequences can be expressed in terms of the DFT, i.e.: | |

* | |

* x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* The conjugate-symmetric output sequence is represented using a CCS vector, | |

* which is of length N+2, and is organized as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . N-2 N-1 N N+1 | |

* Component: R0 0 R1 I1 R2 I2 . . . R[N/2-1] I[N/2-1] R[N/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary | |

* components for FFT bin 'n'. Bins are numbered from 0 to N/2, where | |

* N is the FFT length. Bin index 0 corresponds to the DC component, | |

* and bin index N/2 corresponds to the foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the real-valued input sequence, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* | |

* Output Arguments: | |

* pDst - pointer to output sequence, represented using CCS format, of | |

* length (2^order)+2; must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments, if one or more of the | |

* following is true: - one of the pointers pSrc, pDst, or pFFTSpec | |

* is NULL - pSrc or pDst is not aligned on a 32-byte boundary | |

* | |

*/ | |

OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec | |

); | |

/** | |

* Function: omxSP_FFTInv_CCSToR_S32S16_Sfs (2.2.4.4.4) | |

* | |

* Description: | |

* These functions compute the inverse FFT for a conjugate-symmetric input | |

* sequence. Transform length is determined by the specification structure, | |

* which must be initialized prior to calling the FFT function using | |

* <FFTInit_R_S16S32>. For a transform of length M, the input sequence is | |

* represented using a packed CCS vector of length M+2, and is organized | |

* as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 | |

* Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n. | |

* Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 | |

* corresponds to the DC component, and bin index M/2 corresponds to the | |

* foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input sequence represented using | |

* CCS format, of length (2^order) + 2; must be aligned on a 32-byte | |

* boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scalefactor; range is [0,16] | |

* | |

* Output Arguments: | |

* pDst - pointer to the real-valued output sequence, of length 2^order ; must be | |

* aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: | |

* - pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >16 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs ( | |

const OMX_S32 *pSrc, | |

OMX_S16 *pDst, | |

const OMXFFTSpec_R_S16S32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTInv_CCSToR_S16_Sfs | |

* | |

* Description: | |

* These functions compute the inverse FFT for a conjugate-symmetric input | |

* sequence. Transform length is determined by the specification structure, | |

* which must be initialized prior to calling the FFT function using | |

* <FFTInit_R_S16>. For a transform of length M, the input | |

* sequence is represented using a packed CCS vector of length | |

* M+2, and is organized as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 | |

* Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components | |

* for FFT bin n. | |

* Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 | |

* corresponds to the DC component, and bin index M/2 corresponds to the | |

* foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input sequence represented using | |

* CCS format, of length (2^order) + 2; must be aligned on a 32-byte | |

* boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scalefactor; range is [0,16] | |

* | |

* Output Arguments: | |

* pDst - pointer to the real-valued output sequence, of length 2^order ; must | |

* be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: | |

* - pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >16 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CCSToR_S16_Sfs ( | |

const OMX_S16* pSrc, | |

OMX_S16* pDst, | |

const OMXFFTSpec_R_S16* pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTInv_CCSToR_S32_Sfs (2.2.4.4.4) | |

* | |

* Description: | |

* These functions compute the inverse FFT for a conjugate-symmetric input | |

* sequence. Transform length is determined by the specification structure, | |

* which must be initialized prior to calling the FFT function using | |

* <FFTInit_R_S32>. For a transform of length M, the input sequence is | |

* represented using a packed CCS vector of length M+2, and is organized | |

* as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 | |

* Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n. | |

* Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 | |

* corresponds to the DC component, and bin index M/2 corresponds to the | |

* foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input sequence represented using | |

* CCS format, of length (2^order) + 2; must be aligned on a 32-byte | |

* boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* scaleFactor - output scalefactor; range is [0,32] | |

* | |

* Output Arguments: | |

* pDst - pointer to the real-valued output sequence, of length 2^order ; must be | |

* aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: | |

* - pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CCSToR_S32_Sfs ( | |

const OMX_S32 *pSrc, | |

OMX_S32 *pDst, | |

const OMXFFTSpec_R_S32 *pFFTSpec, | |

OMX_INT scaleFactor | |

); | |

/** | |

* Function: omxSP_FFTInv_CToC_FC32_Sfs (2.2.4.2.4) | |

* | |

* Description: | |

* These functions compute an inverse FFT for a complex signal of | |

* length of 2^order, where 0 <= order <= 15. Transform length is | |

* determined by the specification structure, which must be | |

* initialized prior to calling the FFT function using the appropriate | |

* helper, i.e., <FFTInit_C_FC32>. The relationship between the input | |

* and output sequences can be expressed in terms of the IDFT, i.e.: | |

* | |

* x[n] = SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) | |

* n=0,1,2,...N-1 | |

* N=2^order. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input signal, of length 2^order ; | |

* must be aligned on a 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized specification | |

* structure | |

* | |

* Output Arguments: | |

* order | |

* pDst - pointer to the complex-valued output signal, of length 2^order; | |

* must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* OMX_Sts_BadArgErr - returned if one or more of the following conditions | |

* is true: | |

* - one or more of the following pointers is NULL: pSrc, pDst, or | |

* pFFTSpec. | |

* - pSrc or pDst is not 32-byte aligned | |

* - scaleFactor<0 or scaleFactor>32 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CToC_FC32_Sfs ( | |

const OMX_FC32 *pSrc, | |

OMX_FC32 *pDst, | |

const OMXFFTSpec_C_FC32 *pFFTSpec | |

); | |

/** | |

* Function: omxSP_FFTInv_CCSToR_F32_Sfs | |

* | |

* Description: | |

* These functions compute the inverse FFT for a conjugate-symmetric input | |

* sequence. Transform length is determined by the specification structure, | |

* which must be initialized prior to calling the FFT function using | |

* <FFTInit_R_F32>. For a transform of length M, the input sequence is | |

* represented using a packed CCS vector of length M+2, and is organized | |

* as follows: | |

* | |

* Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 | |

* Comp: R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 | |

* | |

* where R[n] and I[n], respectively, denote the real and imaginary | |

* components for FFT bin n. Bins are numbered from 0 to M/2, where M | |

* is the FFT length. Bin index 0 corresponds to the DC component, | |

* and bin index M/2 corresponds to the foldover frequency. | |

* | |

* Input Arguments: | |

* pSrc - pointer to the complex-valued input sequence represented | |

* using CCS format, of length (2^order) + 2; must be aligned on a | |

* 32-byte boundary. | |

* pFFTSpec - pointer to the preallocated and initialized | |

* specification structure | |

* | |

* Output Arguments: | |

* pDst - pointer to the real-valued output sequence, of length | |

* 2^order ; must be aligned on a 32-byte boundary. | |

* | |

* Return Value: | |

* | |

* OMX_Sts_NoErr - no error | |

* | |

* OMX_Sts_BadArgErr - bad arguments if one or more of the | |

* following is true: | |

* - pSrc, pDst, or pFFTSpec is NULL | |

* - pSrc or pDst is not aligned on a 32-byte boundary | |

* - scaleFactor<0 or scaleFactor >32 | |

* | |

*/ | |

OMXResult omxSP_FFTInv_CCSToR_F32_Sfs( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec | |

); | |

/* | |

* This block sets things up appropriately for run-time or build-time selection | |

* of NEON implementations. | |

*/ | |

#if defined(__arm__) || defined(__aarch64__) | |

/* | |

* Generic versions. Just like their *_Sfs counterparts, but automatically | |

* detect whether NEON is available or not and choose the appropriate routine. | |

*/ | |

#if defined(DL_ARM_NEON_OPTIONAL) | |

extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec | |

); | |

extern OMXResult (*omxSP_FFTInv_CCSToR_F32)( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec); | |

#elif defined(DL_ARM_NEON) | |

/* Build-time NEON selection. */ | |

#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs | |

#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs | |

#else | |

/* Build-time non-NEON selection. */ | |

#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs_vfp | |

#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs_vfp | |

#endif /* defined(DL_ARM_NEON_OPTIONAL) */ | |

#if defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON) | |

/* Non-NEON versions. */ | |

OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec | |

); | |

OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp( | |

const OMX_F32* pSrc, | |

OMX_F32* pDst, | |

const OMXFFTSpec_R_F32* pFFTSpec | |

); | |

OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp ( | |

const OMX_FC32 *pSrc, | |

OMX_FC32 *pDst, | |

const OMXFFTSpec_C_FC32 *pFFTSpec | |

); | |

OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp ( | |

const OMX_FC32 *pSrc, | |

OMX_FC32 *pDst, | |

const OMXFFTSpec_C_FC32 *pFFTSpec | |

); | |

#endif /* defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON) */ | |

#else | |

/* Build-time non-ARM selection. */ | |

#define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs | |

#define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs | |

#endif /* defined(__arm__) || defined(__aarch64__) */ | |

#ifdef __cplusplus | |

} | |

#endif | |

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

/** EOF */ | |