src/third_party/openmax_dl/dl/sp/api/omxSP.h

   1 /**
   2  * File: omxSP.h
   3  * Brief: OpenMAX DL v1.0.2 - Signal Processing library
   4  *
   5  * Copyright 2005-2008 The Khronos Group Inc. All Rights Reserved.
   6  *
   7  * These materials are protected by copyright laws and contain material
   8  * proprietary to the Khronos Group, Inc.  You may use these materials
   9  * for implementing Khronos specifications, without altering or removing
  10  * any trademark, copyright or other notice from the specification.
  11  *
  12  * Khronos Group makes no, and expressly disclaims any, representations
  13  * or warranties, express or implied, regarding these materials, including,
  14  * without limitation, any implied warranties of merchantability or fitness
  15  * for a particular purpose or non-infringement of any intellectual property.
  16  * Khronos Group makes no, and expressly disclaims any, warranties, express
  17  * or implied, regarding the correctness, accuracy, completeness, timeliness,
  18  * and reliability of these materials.
  19  *
  20  * Under no circumstances will the Khronos Group, or any of its Promoters,
  21  * Contributors or Members or their respective partners, officers, directors,
  22  * employees, agents or representatives be liable for any damages, whether
  23  * direct, indirect, special or consequential damages for lost revenues,
  24  * lost profits, or otherwise, arising from or in connection with these
  25  * materials.
  26  *
  27  * Khronos and OpenMAX are trademarks of the Khronos Group Inc.
  28  *
  29  */
  30
  31 /* *****************************************************************************************/
  32
  33 #ifndef _OMXSP_H_
  34 #define _OMXSP_H_
  35
  36 #include "dl/api/omxtypes.h"
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41
  42
  43 /* 2.1 Vendor-Specific FFT Data Structures */
  44  typedef void OMXFFTSpec_C_SC16;
  45  typedef void OMXFFTSpec_C_SC32;
  46  typedef void OMXFFTSpec_R_S16S32;
  47  typedef void OMXFFTSpec_R_S16;
  48  typedef void OMXFFTSpec_R_S32;
  49  typedef void OMXFFTSpec_R_F32;
  50  typedef void OMXFFTSpec_C_FC32;
  51
  52 /**
  53  * Function:  omxSP_Copy_S16   (2.2.1.1.1)
  54  *
  55  * Description:
  56  * Copies the len elements of the vector pointed to by pSrcinto the len
  57  * elements of the vector pointed to by pDst. That is:
  58  *     pDst[i] = pSrc[i], for (i=0, 1, ..., len-1)
  59  *
  60  * Input Arguments:
  61  *
  62  *   pSrc - pointer to the source vector
  63  *   len - number of elements contained in the source and destination vectors
  64  *
  65  * Output Arguments:
  66  *
  67  *   pDst - pointer to the destination vector
  68  *
  69  * Return Value:
  70  *
  71  *    OMX_Sts_NoErr - no error
  72  *    OMX_Sts_BadArgErr - bad arguments detected; returned if one or more of
  73  *              the following is true:
  74  *    -   pSrc or pDst is NULL
  75  *    -   len < 0
  76  *
  77  */
  78 OMXResult omxSP_Copy_S16 (
  79     const OMX_S16 *pSrc,
  80     OMX_S16 *pDst,
  81     OMX_INT len
  82 );
  83
  84
  85
  86 /**
  87  * Function:  omxSP_DotProd_S16   (2.2.2.1.1)
  88  *
  89  * Description:
  90  * Calculates the dot product of the two input vectors.  This function does
  91  * not perform scaling. The internal accumulator width must be at least 32
  92  * bits.  If any of the partially accumulated values exceeds the range of a
  93  * signed 32-bit integer then the result is undefined.
  94  *
  95  * Input Arguments:
  96  *
  97  *   pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
  98  *            boundary.
  99  *   pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
 100  *            boundary.
 101  *   len - length of the vectors in pSrc1 and pSrc2
 102  *
 103  * Output Arguments:
 104  *
 105  * Return Value:
 106  *
 107  *    The dot product result  Note: this function returns the actual result
 108  *              rather than the standard OMXError.
 109  *
 110  */
 111 OMX_S32 omxSP_DotProd_S16 (
 112     const OMX_S16 *pSrc1,
 113     const OMX_S16 *pSrc2,
 114     OMX_INT len
 115 );
 116
 117
 118
 119 /**
 120  * Function:  omxSP_DotProd_S16_Sfs   (2.2.2.1.2)
 121  *
 122  * Description:
 123  * Calculates the dot product of the two input signals with output scaling
 124  * and saturation, i.e., the result is multiplied by two to the power of the
 125  * negative (-)scalefactor (scaled) prior to return.  The result is saturated
 126  * with rounding if the scaling operation produces a value outside the range
 127  * of a signed 32-bit integer. Rounding behavior is defined in section 1.6.7
 128  * Integer Scaling and Rounding Conventions. The internal accumulator width
 129  * must be at least 32 bits. The result is undefined if any of the partially
 130  * accumulated values exceeds the range of a signed 32-bit integer.
 131  *
 132  * Input Arguments:
 133  *
 134  *   pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
 135  *            boundary.
 136  *   pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
 137  *            boundary.
 138  *   len - length of the vectors in pSrc1 and pSrc2
 139  *   scaleFactor - integer scalefactor
 140  *
 141  * Output Arguments:
 142  *
 143  * Return Value:
 144  *
 145  *    The dot product result  Note: This function returns the actual result
 146  *              rather than the standard OMXError.
 147  *
 148  */
 149 OMX_S32 omxSP_DotProd_S16_Sfs (
 150     const OMX_S16 *pSrc1,
 151     const OMX_S16 *pSrc2,
 152     OMX_INT len,
 153     OMX_INT scaleFactor
 154 );
 155
 156
 157
 158 /**
 159  * Function:  omxSP_BlockExp_S16   (2.2.2.2.2)
 160  *
 161  * Description:
 162  * Block exponent calculation for 16-bit and 32-bit signals (count leading
 163  * sign bits). These functions compute the number of extra sign bits of all
 164  * values in the 16-bit and 32-bit input vector pSrc and return the minimum
 165  * sign bit count. This is also the maximum shift value that could be used in
 166  * scaling the block of data.  The functions BlockExp_S16 and
 167  * BlockExp_S32 return the values 15 and 31, respectively, for input vectors in
 168  * which all entries are equal to zero.
 169  *
 170  * Note: These functions differ from other DL functions by not returning the
 171  *       standard OMXError but the actual result.
 172  *
 173  * Input Arguments:
 174  *
 175  *   pSrc - pointer to the input vector
 176  *   len - number of elements contained in the input and output
 177  *         vectors (0 < len < 65536)
 178  *
 179  * Output Arguments:
 180  *
 181  *   none
 182  *
 183  * Return Value:
 184  *
 185  *    Maximum exponent that may be used in scaling
 186  *
 187  */
 188 OMX_INT omxSP_BlockExp_S16 (
 189     const OMX_S16 *pSrc,
 190     OMX_INT len
 191 );
 192
 193
 194
 195 /**
 196  * Function:  omxSP_BlockExp_S32   (2.2.2.2.2)
 197  *
 198  * Description:
 199  * Block exponent calculation for 16-bit and 32-bit signals (count leading
 200  * sign bits). These functions compute the number of extra sign bits of all
 201  * values in the 16-bit and 32-bit input vector pSrc and return the minimum
 202  * sign bit count. This is also the maximum shift value that could be used in
 203  * scaling the block of data.  The functions BlockExp_S16 and
 204  * BlockExp_S32 return the values 15 and 31, respectively, for input vectors in
 205  * which all entries are equal to zero.
 206  *
 207  * Note: These functions differ from other DL functions by not returning the
 208  *       standard OMXError but the actual result.
 209  *
 210  * Input Arguments:
 211  *
 212  *   pSrc - pointer to the input vector
 213  *   len - number of elements contained in the input and output
 214  *         vectors (0 < len < 65536)
 215  *
 216  * Output Arguments:
 217  *
 218  *   none
 219  *
 220  * Return Value:
 221  *
 222  *    Maximum exponent that may be used in scaling
 223  *
 224  */
 225 OMX_INT omxSP_BlockExp_S32 (
 226     const OMX_S32 *pSrc,
 227     OMX_INT len
 228 );
 229
 230
 231
 232 /**
 233  * Function:  omxSP_FIR_Direct_S16   (2.2.3.1.1)
 234  *
 235  * Description:
 236  * Block FIR filtering for 16-bit data type.  This function applies the
 237  * FIR filter defined by the coefficient vector pTapsQ15 to a vector of
 238  * input data.  The result is saturated with rounding if the operation
 239  * produces a value outside the range of a signed 16-bit integer.
 240  * Rounding behavior is defined in:
 241  *     section 1.6.7 "Integer Scaling and Rounding Conventions".
 242  * The internal accumulator width must be at least 32 bits.  The result
 243  * is undefined if any of the partially accumulated values exceeds the
 244  * range of a signed 32-bit integer.
 245  *
 246  *
 247  * Input Arguments:
 248  *
 249  *   pSrc   - pointer to the vector of input samples to which the
 250  *            filter is applied
 251  *   sampLen - the number of samples contained in the input and output
 252  *            vectors
 253  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 254  *            represented in Q0.15 format (defined in section 1.6.5). Given
 255  *            that:
 256  *                    -32768 = pTapsQ15(k) < 32768,
 257  *                     0 = k <tapsLen,
 258  *            the range on the actual filter coefficients is -1 = bK <1, and
 259  *            therefore coefficient normalization may be required during the
 260  *            filter design process.
 261  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 262  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 263  *            (state). The user is responsible for allocation, initialization,
 264  *            and de-allocation. The filter memory elements are initialized to
 265  *            zero in most applications.
 266  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 267  *            internally by the function. The user should initialize the value
 268  *            of this index to zero.
 269  *
 270  * Output Arguments:
 271  *
 272  *   pDst   - pointer to the vector of filtered output samples
 273  *
 274  * Return Value:
 275  *
 276  *    OMX_Sts_NoErr - no error
 277  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 278  *              following is true:
 279  *    -   One or more of the following pointers is NULL:
 280  *          -  pSrc,
 281  *          -  pDst,
 282  *          -  pSrcDst,
 283  *          -  pTapsQ15,
 284  *          -  pDelayLine, or
 285  *          -  pDelayLineIndex
 286  *    -   samplen < 0
 287  *    -   tapslen < 1
 288  *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 289  *
 290  */
 291 OMXResult omxSP_FIR_Direct_S16 (
 292     const OMX_S16 *pSrc,
 293     OMX_S16 *pDst,
 294     OMX_INT sampLen,
 295     const OMX_S16 *pTapsQ15,
 296     OMX_INT tapsLen,
 297     OMX_S16 *pDelayLine,
 298     OMX_INT *pDelayLineIndex
 299 );
 300
 301
 302
 303 /**
 304  * Function:  omxSP_FIR_Direct_S16_I   (2.2.3.1.1)
 305  *
 306  * Description:
 307  * Block FIR filtering for 16-bit data type.  This function applies the
 308  * FIR filter defined by the coefficient vector pTapsQ15 to a vector of
 309  * input data.  The result is saturated with rounding if the operation
 310  * produces a value outside the range of a signed 16-bit integer.
 311  * Rounding behavior is defined in:
 312  *     section 1.6.7 "Integer Scaling and Rounding Conventions".
 313  * The internal accumulator width must be at least 32 bits.  The result
 314  * is undefined if any of the partially accumulated values exceeds the
 315  * range of a signed 32-bit integer.
 316  *
 317  * Input Arguments:
 318  *
 319  *   pSrcDst - pointer to the vector of input samples to which the
 320  *            filter is applied
 321  *   sampLen - the number of samples contained in the input and output
 322  *            vectors
 323  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 324  *            represented in Q0.15 format (defined in section 1.6.5). Given
 325  *            that:
 326  *                    -32768 = pTapsQ15(k) < 32768,
 327  *                     0 = k <tapsLen,
 328  *            the range on the actual filter coefficients is -1 = bK <1, and
 329  *            therefore coefficient normalization may be required during the
 330  *            filter design process.
 331  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 332  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 333  *            (state). The user is responsible for allocation, initialization,
 334  *            and de-allocation. The filter memory elements are initialized to
 335  *            zero in most applications.
 336  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 337  *            internally by the function. The user should initialize the value
 338  *            of this index to zero.
 339  *
 340  * Output Arguments:
 341  *
 342  *   pSrcDst - pointer to the vector of filtered output samples
 343  *
 344  * Return Value:
 345  *
 346  *    OMX_Sts_NoErr - no error
 347  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 348  *              following is true:
 349  *    -   One or more of the following pointers is NULL:
 350  *          -  pSrc,
 351  *          -  pDst,
 352  *          -  pSrcDst,
 353  *          -  pTapsQ15,
 354  *          -  pDelayLine, or
 355  *          -  pDelayLineIndex
 356  *    -   samplen < 0
 357  *    -   tapslen < 1
 358  *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 359  *
 360  */
 361 OMXResult omxSP_FIR_Direct_S16_I (
 362     OMX_S16 *pSrcDst,
 363     OMX_INT sampLen,
 364     const OMX_S16 *pTapsQ15,
 365     OMX_INT tapsLen,
 366     OMX_S16 *pDelayLine,
 367     OMX_INT *pDelayLineIndex
 368 );
 369
 370
 371
 372 /**
 373  * Function:  omxSP_FIR_Direct_S16_Sfs   (2.2.3.1.1)
 374  *
 375  * Description:
 376  * Block FIR filtering for 16-bit data type. This function applies
 377  * the FIR filter defined by the coefficient vector pTapsQ15 to a
 378  * vector of input data.  The output is multiplied by 2 to the negative
 379  * power of scalefactor (i.e., 2^-scalefactor) before returning to the caller.
 380  * Scaling and rounding conventions are defined in section 1.6.7.
 381  * The internal accumulator width must be at least 32 bits.
 382  * The result is undefined if any of the partially accumulated
 383  * values exceeds the range of a signed 32-bit integer.
 384  *
 385  * Input Arguments:
 386  *
 387  *   pSrc    - pointer to the vector of input samples to which the
 388  *            filter is applied
 389  *   sampLen - the number of samples contained in the input and output
 390  *            vectors
 391  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 392  *            represented in Q0.15 format (defined in section 1.6.5). Given
 393  *            that:
 394  *                    -32768 = pTapsQ15(k) < 32768,
 395  *                     0 = k <tapsLen,
 396  *            the range on the actual filter coefficients is -1 = bK <1, and
 397  *            therefore coefficient normalization may be required during the
 398  *            filter design process.
 399  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 400  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 401  *            (state). The user is responsible for allocation, initialization,
 402  *            and de-allocation. The filter memory elements are initialized to
 403  *            zero in most applications.
 404  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 405  *            internally by the function. The user should initialize the value
 406  *            of this index to zero.
 407  *   scaleFactor - saturation fixed scalefactor
 408  *
 409  * Output Arguments:
 410  *
 411  *   pDst  - pointer to the vector of filtered output samples
 412  *
 413  * Return Value:
 414  *
 415  *    OMX_Sts_NoErr - no error
 416  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 417  *              following is true:
 418  *    -   One or more of the following pointers is NULL:
 419  *          -  pSrc,
 420  *          -  pDst,
 421  *          -  pSrcDst,
 422  *          -  pTapsQ15,
 423  *          -  pDelayLine, or
 424  *          -  pDelayLineIndex
 425  *    -   samplen < 0
 426  *    -   tapslen < 1
 427  *    -   scaleFactor < 0
 428  *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 429  *
 430  */
 431 OMXResult omxSP_FIR_Direct_S16_Sfs (
 432     const OMX_S16 *pSrc,
 433     OMX_S16 *pDst,
 434     OMX_INT sampLen,
 435     const OMX_S16 *pTapsQ15,
 436     OMX_INT tapsLen,
 437     OMX_S16 *pDelayLine,
 438     OMX_INT *pDelayLineIndex,
 439     OMX_INT scaleFactor
 440 );
 441
 442
 443
 444 /**
 445  * Function:  omxSP_FIR_Direct_S16_ISfs   (2.2.3.1.1)
 446  *
 447  * Description:
 448  * Block FIR filtering for 16-bit data type. This function applies
 449  * the FIR filter defined by the coefficient vector pTapsQ15 to a
 450  * vector of input data.  The output is multiplied by 2 to the negative
 451  * power of scalefactor (i.e., 2^-scalefactor) before returning to the caller.
 452  * Scaling and rounding conventions are defined in section 1.6.7.
 453  * The internal accumulator width must be at least 32 bits.
 454  * The result is undefined if any of the partially accumulated
 455  * values exceeds the range of a signed 32-bit integer.
 456  *
 457  * Input Arguments:
 458  *
 459  *   pSrcDst - pointer to the vector of input samples to which the
 460  *            filter is applied
 461  *   sampLen - the number of samples contained in the input and output
 462  *            vectors
 463  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 464  *            represented in Q0.15 format (defined in section 1.6.5). Given
 465  *            that:
 466  *                    -32768 = pTapsQ15(k) < 32768,
 467  *                     0 = k <tapsLen,
 468  *            the range on the actual filter coefficients is -1 = bK <1, and
 469  *            therefore coefficient normalization may be required during the
 470  *            filter design process.
 471  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 472  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 473  *            (state). The user is responsible for allocation, initialization,
 474  *            and de-allocation. The filter memory elements are initialized to
 475  *            zero in most applications.
 476  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 477  *            internally by the function. The user should initialize the value
 478  *            of this index to zero.
 479  *   scaleFactor - saturation fixed scalefactor
 480  *
 481  * Output Arguments:
 482  *
 483  *   pSrcDst - pointer to the vector of filtered output samples
 484  *
 485  * Return Value:
 486  *
 487  *    OMX_Sts_NoErr - no error
 488  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 489  *              following is true:
 490  *    -   One or more of the following pointers is NULL:
 491  *          -  pSrc,
 492  *          -  pDst,
 493  *          -  pSrcDst,
 494  *          -  pTapsQ15,
 495  *          -  pDelayLine, or
 496  *          -  pDelayLineIndex
 497  *    -   samplen < 0
 498  *    -   tapslen < 1
 499  *    -   scaleFactor < 0
 500  *    -   *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
 501  *
 502  */
 503 OMXResult omxSP_FIR_Direct_S16_ISfs (
 504     OMX_S16 *pSrcDst,
 505     OMX_INT sampLen,
 506     const OMX_S16 *pTapsQ15,
 507     OMX_INT tapsLen,
 508     OMX_S16 *pDelayLine,
 509     OMX_INT *pDelayLineIndex,
 510     OMX_INT scaleFactor
 511 );
 512
 513
 514
 515 /**
 516  * Function:  omxSP_FIROne_Direct_S16   (2.2.3.1.2)
 517  *
 518  * Description:
 519  * Single-sample FIR filtering for 16-bit data type. These functions apply
 520  * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 521  * sample of input data. The result is saturated with rounding if the
 522  * operation produces a value outside the range of a signed 16-bit integer.
 523  * Rounding behavior is defined in:
 524  *       section 1.6.7 "Integer Scaling and Rounding Conventions".
 525  * The internal accumulator width must be at least 32 bits.  The result is
 526  * undefined if any of the partially accumulated values exceeds the range of a
 527  * signed 32-bit integer.
 528  *
 529  * Input Arguments:
 530  *
 531  *   val      - the single input sample to which the filter is
 532  *            applied.
 533  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 534  *            represented in Q0.15 format (as defined in section 1.6.5). Given
 535  *            that:
 536  *                    -32768 = pTapsQ15(k) < 32768,
 537  *                         0 = k < tapsLen,
 538  *            the range on the actual filter coefficients is -1 = bK <1, and
 539  *            therefore coefficient normalization may be required during the
 540  *            filter design process.
 541  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 542  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 543  *            (state). The user is responsible for allocation, initialization,
 544  *            and de-allocation. The filter memory elements are initialized to
 545  *            zero in most applications.
 546  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 547  *            internally by the function. The user should initialize the value
 548  *            of this index to zero.
 549  *
 550  * Output Arguments:
 551  *
 552  *   pResult - pointer to the filtered output sample
 553  *
 554  * Return Value:
 555  *
 556  *    OMX_Sts_NoErr - no error
 557  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 558  *              following is true:
 559  *    -    One or more of the following pointers is NULL:
 560  *            -  pResult,
 561  *            -  pTapsQ15,
 562  *            -  pDelayLine, or
 563  *            -  pDelayLineIndex
 564  *    -    tapslen < 1
 565  *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 566  *
 567  */
 568 OMXResult omxSP_FIROne_Direct_S16 (
 569     OMX_S16 val,
 570     OMX_S16 *pResult,
 571     const OMX_S16 *pTapsQ15,
 572     OMX_INT tapsLen,
 573     OMX_S16 *pDelayLine,
 574     OMX_INT *pDelayLineIndex
 575 );
 576
 577
 578
 579 /**
 580  * Function:  omxSP_FIROne_Direct_S16_I   (2.2.3.1.2)
 581  *
 582  * Description:
 583  * Single-sample FIR filtering for 16-bit data type. These functions apply
 584  * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 585  * sample of input data. The result is saturated with rounding if the
 586  * operation produces a value outside the range of a signed 16-bit integer.
 587  * Rounding behavior is defined in:
 588  *       section 1.6.7 "Integer Scaling and Rounding Conventions".
 589  * The internal accumulator width must be at least 32 bits.  The result is
 590  * undefined if any of the partially accumulated values exceeds the range of a
 591  * signed 32-bit integer.
 592  *
 593  * Input Arguments:
 594  *
 595  *   pValResult - pointer to the single input sample to which the filter is
 596  *            applied.
 597  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 598  *            represented in Q0.15 format (as defined in section 1.6.5). Given
 599  *            that:
 600  *                    -32768 = pTapsQ15(k) < 32768,
 601  *                         0 = k < tapsLen,
 602  *            the range on the actual filter coefficients is -1 = bK <1, and
 603  *            therefore coefficient normalization may be required during the
 604  *            filter design process.
 605  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 606  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 607  *            (state). The user is responsible for allocation, initialization,
 608  *            and de-allocation. The filter memory elements are initialized to
 609  *            zero in most applications.
 610  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 611  *            internally by the function. The user should initialize the value
 612  *            of this index to zero.
 613  *
 614  * Output Arguments:
 615  *
 616  *   pValResult - pointer to the filtered output sample
 617  *
 618  * Return Value:
 619  *
 620  *    OMX_Sts_NoErr - no error
 621  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 622  *              following is true:
 623  *    -    One or more of the following pointers is NULL:
 624  *            -  pValResult,
 625  *            -  pTapsQ15,
 626  *            -  pDelayLine, or
 627  *            -  pDelayLineIndex
 628  *    -    tapslen < 1
 629  *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 630  *
 631  */
 632 OMXResult omxSP_FIROne_Direct_S16_I (
 633     OMX_S16 *pValResult,
 634     const OMX_S16 *pTapsQ15,
 635     OMX_INT tapsLen,
 636     OMX_S16 *pDelayLine,
 637     OMX_INT *pDelayLineIndex
 638 );
 639
 640
 641
 642 /**
 643  * Function:  omxSP_FIROne_Direct_S16_Sfs   (2.2.3.1.2)
 644  *
 645  * Description:
 646  * Single-sample FIR filtering for 16-bit data type. These functions apply
 647  * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 648  * sample of input data. The output is multiplied by 2 to the negative power
 649  * of scalefactor (i.e., 2^-scalefactor) before returning to the user.
 650  * Scaling and rounding conventions are defined in section 1.6.7.
 651  * The internal accumulator width must be at least 32 bits.
 652  * The result is undefined if any of the partially accumulated values exceeds
 653  * the range of a signed 32-bit integer.
 654  *
 655  * Input Arguments:
 656  *
 657  *   val      - the single input sample to which the filter is
 658  *            applied.
 659  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 660  *            represented in Q0.15 format (as defined in section 1.6.5). Given
 661  *            that:
 662  *                    -32768 = pTapsQ15(k) < 32768,
 663  *                         0 = k < tapsLen,
 664  *            the range on the actual filter coefficients is -1 = bK <1, and
 665  *            therefore coefficient normalization may be required during the
 666  *            filter design process.
 667  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 668  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 669  *            (state). The user is responsible for allocation, initialization,
 670  *            and de-allocation. The filter memory elements are initialized to
 671  *            zero in most applications.
 672  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 673  *            internally by the function. The user should initialize the value
 674  *            of this index to zero.
 675  *   scaleFactor - saturation fixed scaleFactor
 676  *
 677  * Output Arguments:
 678  *
 679  *   pResult - pointer to the filtered output sample
 680  *
 681  * Return Value:
 682  *
 683  *    OMX_Sts_NoErr - no error
 684  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 685  *              following is true:
 686  *    -    One or more of the following pointers is NULL:
 687  *            -  pResult,
 688  *            -  pTapsQ15,
 689  *            -  pDelayLine, or
 690  *            -  pDelayLineIndex
 691  *    -    tapslen < 1
 692  *    -    scaleFactor < 0
 693  *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 694  *
 695  */
 696 OMXResult omxSP_FIROne_Direct_S16_Sfs (
 697     OMX_S16 val,
 698     OMX_S16 *pResult,
 699     const OMX_S16 *pTapsQ15,
 700     OMX_INT tapsLen,
 701     OMX_S16 *pDelayLine,
 702     OMX_INT *pDelayLineIndex,
 703     OMX_INT scaleFactor
 704 );
 705
 706
 707
 708 /**
 709  * Function:  omxSP_FIROne_Direct_S16_ISfs   (2.2.3.1.2)
 710  *
 711  * Description:
 712  * Single-sample FIR filtering for 16-bit data type. These functions apply
 713  * the FIR filter defined by the coefficient vector pTapsQ15 to a single
 714  * sample of input data. The output is multiplied by 2 to the negative power
 715  * of scalefactor (i.e., 2^-scalefactor) before returning to the user.
 716  * Scaling and rounding conventions are defined in section 1.6.7.
 717  * The internal accumulator width must be at least 32 bits.
 718  * The result is undefined if any of the partially accumulated values exceeds
 719  * the range of a signed 32-bit integer.
 720  *
 721  * Input Arguments:
 722  *
 723  *   pValResult - the pointer to a single input sample to which the filter is
 724  *            applied.
 725  *   pTapsQ15 - pointer to the vector that contains the filter coefficients,
 726  *            represented in Q0.15 format (as defined in section 1.6.5). Given
 727  *            that:
 728  *                    -32768 = pTapsQ15(k) < 32768,
 729  *                         0 = k < tapsLen,
 730  *            the range on the actual filter coefficients is -1 = bK <1, and
 731  *            therefore coefficient normalization may be required during the
 732  *            filter design process.
 733  *   tapsLen - the number of taps, or, equivalently, the filter order + 1
 734  *   pDelayLine - pointer to the 2.tapsLen -element filter memory buffer
 735  *            (state). The user is responsible for allocation, initialization,
 736  *            and de-allocation. The filter memory elements are initialized to
 737  *            zero in most applications.
 738  *   pDelayLineIndex - pointer to the filter memory index that is maintained
 739  *            internally by the function. The user should initialize the value
 740  *            of this index to zero.
 741  *   scaleFactor - saturation fixed scaleFactor
 742  *
 743  * Output Arguments:
 744  *
 745  *   pValResult - pointer to the filtered output sample
 746  *
 747  * Return Value:
 748  *
 749  *    OMX_Sts_NoErr - no error
 750  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 751  *              following is true:
 752  *    -    One or more of the following pointers is NULL:
 753  *            -  pValResult,
 754  *            -  pTapsQ15,
 755  *            -  pDelayLine, or
 756  *            -  pDelayLineIndex
 757  *    -    tapslen < 1
 758  *    -    scaleFactor < 0
 759  *    -    *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
 760  *
 761  */
 762 OMXResult omxSP_FIROne_Direct_S16_ISfs (
 763     OMX_S16 *pValResult,
 764     const OMX_S16 *pTapsQ15,
 765     OMX_INT tapsLen,
 766     OMX_S16 *pDelayLine,
 767     OMX_INT *pDelayLineIndex,
 768     OMX_INT scaleFactor
 769 );
 770
 771
 772
 773 /**
 774  * Function:  omxSP_IIR_Direct_S16   (2.2.3.2.1)
 775  *
 776  * Description:
 777  * Block IIR filtering for 16-bit data. This function applies the direct form
 778  * II IIR filter defined by the coefficient vector pTaps to a vector of input
 779  * data.  The internal accumulator width must be at least 32 bits, and the
 780  * result is saturated if the operation produces a value outside the range of
 781  * a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768)
 782  * for a negative overflow or 0x7fff (32767) for a positive overflow.  The
 783  * result is undefined if any of the partially accumulated values exceeds the
 784  * range of a signed 32-bit integer.
 785  *
 786  * Input Arguments:
 787  *
 788  *   pSrc  - pointer to the vector of input samples to which the
 789  *            filter is applied
 790  *   len - the number of samples contained in both the input and output
 791  *            vectors
 792  *   pTaps - pointer to the 2L+2-element vector that contains the combined
 793  *            numerator and denominator filter coefficients from the system
 794  *            transfer function, H(z). Coefficient scaling and coefficient
 795  *            vector organization should follow the conventions described
 796  *            above. The value of the coefficient scaleFactor exponent must be
 797  *            non-negative (sf=0).
 798  *   order - the maximum of the degrees of the numerator and denominator
 799  *            coefficient polynomials from the system transfer function, H(z).
 800  *            In the notation of section 2.2.3.2, the parameter
 801  *            order=max(K,M)=L gives the maximum delay, in samples, used to
 802  *            compute each output sample.
 803  *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 804  *            user is responsible for allocation, initialization, and
 805  *            deallocation. The filter memory elements are initialized to zero
 806  *            in most applications.
 807  *
 808  * Output Arguments:
 809  *
 810  *   pDst - pointer to the vector of filtered output samples
 811  *
 812  * Return Value:
 813  *
 814  *    OMX_Sts_NoErr - no error
 815  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 816  *              following is true:
 817  *    -    one or more of the following pointers is NULL:
 818  *             -  pSrc,
 819  *             -  pDst,
 820  *             -  pTaps, or
 821  *             -  pDelayLine.
 822  *    -    len < 0
 823  *    -    pTaps[order+1] < 0 (negative scaling)
 824  *    -    order < 1
 825  *
 826  */
 827 OMXResult omxSP_IIR_Direct_S16 (
 828     const OMX_S16 *pSrc,
 829     OMX_S16 *pDst,
 830     OMX_INT len,
 831     const OMX_S16 *pTaps,
 832     OMX_INT order,
 833     OMX_S32 *pDelayLine
 834 );
 835
 836
 837
 838 /**
 839  * Function:  omxSP_IIR_Direct_S16_I   (2.2.3.2.1)
 840  *
 841  * Description:
 842  * Block IIR filtering for 16-bit data. This function applies the direct form
 843  * II IIR filter defined by the coefficient vector pTaps to a vector of input
 844  * data.  The internal accumulator width must be at least 32 bits, and the
 845  * result is saturated if the operation produces a value outside the range of
 846  * a signed 16-bit integer, i.e., the output will saturate to 0x8000 (-32768)
 847  * for a negative overflow or 0x7fff (32767) for a positive overflow.  The
 848  * result is undefined if any of the partially accumulated values exceeds the
 849  * range of a signed 32-bit integer.
 850  *
 851  * Input Arguments:
 852  *
 853  *   pSrcDst - pointer to the vector of input samples to which the
 854  *            filter is applied
 855  *   len - the number of samples contained in both the input and output
 856  *            vectors
 857  *   pTaps - pointer to the 2L+2-element vector that contains the combined
 858  *            numerator and denominator filter coefficients from the system
 859  *            transfer function, H(z). Coefficient scaling and coefficient
 860  *            vector organization should follow the conventions described
 861  *            above. The value of the coefficient scaleFactor exponent must be
 862  *            non-negative (sf>=0).
 863  *   order - the maximum of the degrees of the numerator and denominator
 864  *            coefficient polynomials from the system transfer function, H(z).
 865  *            In the notation of section 2.2.3.2, the parameter
 866  *            order=max(K,M)=L gives the maximum delay, in samples, used to
 867  *            compute each output sample.
 868  *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 869  *            user is responsible for allocation, initialization, and
 870  *            deallocation. The filter memory elements are initialized to zero
 871  *            in most applications.
 872  *
 873  * Output Arguments:
 874  *
 875  *   pSrcDst - pointer to the vector of filtered output samples
 876  *
 877  * Return Value:
 878  *
 879  *    OMX_Sts_NoErr - no error
 880  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 881  *              following is true:
 882  *    -    one or more of the following pointers is NULL:
 883  *             -  pSrcDst,
 884  *             -  pTaps, or
 885  *             -  pDelayLine.
 886  *    -    len < 0
 887  *    -    pTaps[order+1] < 0 (negative scaling)
 888  *    -    order < 1
 889  *
 890  */
 891 OMXResult omxSP_IIR_Direct_S16_I (
 892     OMX_S16 *pSrcDst,
 893     OMX_INT len,
 894     const OMX_S16 *pTaps,
 895     OMX_INT order,
 896     OMX_S32 *pDelayLine
 897 );
 898
 899
 900
 901 /**
 902  * Function:  omxSP_IIROne_Direct_S16   (2.2.3.2.2)
 903  *
 904  * Description:
 905  * Single sample IIR filtering for 16-bit data.  This function applies the
 906  * direct form II IIR filter defined by the coefficient vector pTaps to a
 907  * single sample of input data. The internal accumulator width must be at
 908  * least 32 bits, and the result is saturated if the operation produces a
 909  * value outside the range of a signed 16-bit integer, i.e., the output will
 910  * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 911  * positive overflow.  The result is undefined if any of the partially
 912  * accumulated values exceeds the range of a signed 32-bit integer.
 913  *
 914  * Input Arguments:
 915  *
 916  *   val - the single input sample to which the filter is
 917  *            applied.
 918  *   pTaps - pointer to the 2L+2 -element vector that contains the combined
 919  *            numerator and denominator filter coefficients from the system
 920  *            transfer function, H(z). Coefficient scaling and coefficient
 921  *            vector organization should follow the conventions described
 922  *            above. The value of the coefficient scaleFactor exponent must be
 923  *            non-negative (sf>=0).
 924  *   order - the maximum of the degrees of the numerator and denominator
 925  *            coefficient polynomials from the system transfer function, H(z).
 926  *            In the notation of section 2.2.3.2, the parameter
 927  *            order=max(K,M)=L gives the maximum delay, in samples, used to
 928  *            compute each output sample.
 929  *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 930  *            user is responsible for allocation, initialization, and
 931  *            deallocation. The filter memory elements are initialized to zero
 932  *            in most applications.
 933  *
 934  * Output Arguments:
 935  *
 936  *   pResult - pointer to the filtered output sample
 937  *
 938  * Return Value:
 939  *
 940  *    OMX_Sts_NoErr - no error
 941  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
 942  *              following is true:
 943  *    -    one or more of the following pointers is NULL: pResult,
 944  *              pTaps, or pDelayLine.
 945  *    -    order < 1
 946  *    -    pTaps[order+1] < 0 (negative scaling)
 947  *
 948  */
 949 OMXResult omxSP_IIROne_Direct_S16 (
 950     OMX_S16 val,
 951     OMX_S16 *pResult,
 952     const OMX_S16 *pTaps,
 953     OMX_INT order,
 954     OMX_S32 *pDelayLine
 955 );
 956
 957
 958
 959 /**
 960  * Function:  omxSP_IIROne_Direct_S16_I   (2.2.3.2.2)
 961  *
 962  * Description:
 963  * Single sample IIR filtering for 16-bit data.  This function applies the
 964  * direct form II IIR filter defined by the coefficient vector pTaps to a
 965  * single sample of input data. The internal accumulator width must be at
 966  * least 32 bits, and the result is saturated if the operation produces a
 967  * value outside the range of a signed 16-bit integer, i.e., the output will
 968  * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
 969  * positive overflow.  The result is undefined if any of the partially
 970  * accumulated values exceeds the range of a signed 32-bit integer.
 971  *
 972  * Input Arguments:
 973  *
 974  *   pValResult - pointer to the single input sample to which the filter is
 975  *            applied.
 976  *   pTaps - pointer to the 2L+2 -element vector that contains the combined
 977  *            numerator and denominator filter coefficients from the system
 978  *            transfer function, H(z). Coefficient scaling and coefficient
 979  *            vector organization should follow the conventions described
 980  *            above. The value of the coefficient scaleFactor exponent must be
 981  *            non-negative (sf>=0).
 982  *   order - the maximum of the degrees of the numerator and denominator
 983  *            coefficient polynomials from the system transfer function, H(z).
 984  *            In the notation of section 2.2.3.2, the parameter
 985  *            order=max(K,M)=L gives the maximum delay, in samples, used to
 986  *            compute each output sample.
 987  *   pDelayLine - pointer to the L-element filter memory buffer (state). The
 988  *            user is responsible for allocation, initialization, and
 989  *            deallocation. The filter memory elements are initialized to zero
 990  *            in most applications.
 991  *
 992  * Output Arguments:
 993  *
 994  *   pValResult - pointer to the filtered output sample
 995  *
 996  * Return Value:
 997  *
 998  *    OMX_Sts_NoErr - no error
 999  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1000  *              following is true:
1001  *    -    one or more of the following pointers is NULL:
1002  *              pValResult, pTaps, or pDelayLine.
1003  *    -    order < 1
1004  *    -    pTaps[order+1] < 0 (negative scaling)
1005  *
1006  */
1007 OMXResult omxSP_IIROne_Direct_S16_I (
1008     OMX_S16 *pValResult,
1009     const OMX_S16 *pTaps,
1010     OMX_INT order,
1011     OMX_S32 *pDelayLine
1012 );
1013
1014
1015
1016 /**
1017  * Function:  omxSP_IIR_BiQuadDirect_S16   (2.2.3.3.1)
1018  *
1019  * Description:
1020  * Block biquad IIR filtering for 16-bit data type. This function applies the
1021  * direct form II biquad IIR cascade defined by the coefficient vector pTaps
1022  * to a vector of input data.  The internal accumulator width must be at least
1023  * 32 bits, and the result is saturated if the operation produces a value
1024  * outside the range of a signed 16-bit integer, i.e., the output will
1025  * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
1026  * positive overflow.  The result is undefined if any of the partially
1027  * accumulated values exceeds the range of a signed 32-bit integer.
1028  *
1029  * Input Arguments:
1030  *
1031  *   pSrc - pointer to the vector of input samples to which the
1032  *            filter is applied
1033  *   len - the number of samples contained in both the input and output
1034  *            vectors
1035  *   pTaps - pointer to the 6P -element vector that contains the combined
1036  *            numerator and denominator filter coefficients from the biquad
1037  *            cascade. Coefficient scaling and coefficient vector organization
1038  *            should follow the conventions described above. The value of the
1039  *            coefficient scaleFactor exponent must be non-negative. (sfp>=0).
1040  *   numBiquad - the number of biquads contained in the IIR filter cascade:
1041  *            (P)
1042  *   pDelayLine - pointer to the 2P -element filter memory buffer (state).
1043  *            The user is responsible for allocation, initialization, and
1044  *            de-allocation. The filter memory elements are initialized to
1045  *            zero in most applications.
1046  *
1047  * Output Arguments:
1048  *
1049  *   pDst - pointer to the vector of filtered output samples
1050  *
1051  * Return Value:
1052  *
1053  *    OMX_Sts_NoErr - no error
1054  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1055  *              following is true:
1056  *    -    one or more of the following pointers is NULL: pSrc, pDst,
1057  *              pTaps, or pDelayLine.
1058  *    -    len < 0
1059  *    -    numBiquad < 1
1060  *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1061  *
1062  */
1063 OMXResult omxSP_IIR_BiQuadDirect_S16 (
1064     const OMX_S16 *pSrc,
1065     OMX_S16 *pDst,
1066     OMX_INT len,
1067     const OMX_S16 *pTaps,
1068     OMX_INT numBiquad,
1069     OMX_S32 *pDelayLine
1070 );
1071
1072
1073
1074 /**
1075  * Function:  omxSP_IIR_BiQuadDirect_S16_I   (2.2.3.3.1)
1076  *
1077  * Description:
1078  * Block biquad IIR filtering for 16-bit data type. This function applies the
1079  * direct form II biquad IIR cascade defined by the coefficient vector pTaps
1080  * to a vector of input data.  The internal accumulator width must be at least
1081  * 32 bits, and the result is saturated if the operation produces a value
1082  * outside the range of a signed 16-bit integer, i.e., the output will
1083  * saturate to 0x8000 (-32768) for a negative overflow or 0x7fff (32767) for a
1084  * positive overflow.  The result is undefined if any of the partially
1085  * accumulated values exceeds the range of a signed 32-bit integer.
1086  *
1087  * Input Arguments:
1088  *
1089  *   pSrcDst - pointer to the vector of input samples to which the
1090  *            filter is applied
1091  *   len - the number of samples contained in both the input and output
1092  *            vectors
1093  *   pTaps - pointer to the 6P -element vector that contains the combined
1094  *            numerator and denominator filter coefficients from the biquad
1095  *            cascade. Coefficient scaling and coefficient vector organization
1096  *            should follow the conventions described above. The value of the
1097  *            coefficient scaleFactor exponent must be non-negative. (sfp>=0).
1098  *   numBiquad - the number of biquads contained in the IIR filter cascade:
1099  *            (P)
1100  *   pDelayLine - pointer to the 2P -element filter memory buffer (state).
1101  *            The user is responsible for allocation, initialization, and
1102  *            de-allocation. The filter memory elements are initialized to
1103  *            zero in most applications.
1104  *
1105  * Output Arguments:
1106  *
1107  *   pSrcDst - pointer to the vector of filtered output samples
1108  *
1109  * Return Value:
1110  *
1111  *    OMX_Sts_NoErr - no error
1112  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1113  *              following is true:
1114  *    -    one or more of the following pointers is NULL:
1115  *              pSrcDst, pTaps, or pDelayLine.
1116  *    -    len < 0
1117  *    -    numBiquad < 1
1118  *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1119  *
1120  */
1121 OMXResult omxSP_IIR_BiQuadDirect_S16_I (
1122     OMX_S16 *pSrcDst,
1123     OMX_INT len,
1124     const OMX_S16 *pTaps,
1125     OMX_INT numBiquad,
1126     OMX_S32 *pDelayLine
1127 );
1128
1129
1130
1131 /**
1132  * Function:  omxSP_IIROne_BiQuadDirect_S16   (2.2.3.3.2)
1133  *
1134  * Description:
1135  * Single-sample biquad IIR filtering for 16-bit data type. This function
1136  * applies the direct form II biquad IIR cascade defined by the coefficient
1137  * vector pTaps to a single sample of input data.  The internal accumulator
1138  * width must be at least 32 bits, and the result is saturated if the
1139  * operation produces a value outside the range of a signed 16-bit integer,
1140  * i.e., the output will saturate to 0x8000 (-32768) for a negative overflow
1141  * or 0x7fff (32767) for a positive overflow.  The result is undefined if any
1142  * of the partially accumulated values exceeds the range of a signed 32-bit
1143  * integer.
1144  *
1145  * Input Arguments:
1146  *
1147  *   val   - the single input sample to which the filter is
1148  *            applied.
1149  *   pTaps - pointer to the 6P-element vector that contains the combined
1150  *            numerator and denominator filter coefficients from the biquad
1151  *            cascade. Coefficient scaling and coefficient vector organization
1152  *            should follow the conventions described above. The value of the
1153  *            coefficient scalefactor exponent must be non-negative: (sfp>=0).
1154  *   numBiquad - the number of biquads contained in the IIR filter cascade:
1155  *            (P)
1156  *   pDelayLine - pointer to the 2p-element filter memory buffer (state). The
1157  *            user is responsible for allocation, initialization, and
1158  *            deallocation. The filter memory elements are initialized to zero
1159  *            in most applications.
1160  *
1161  * Output Arguments:
1162  *
1163  *   pResult - pointer to the filtered output sample
1164  *
1165  * Return Value:
1166  *
1167  *    OMX_Sts_NoErr - no error
1168  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1169  *              following is true:
1170  *    -    one or more of the following pointers is NULL: pResult,
1171  *              pValResult, pTaps, or pDelayLine.
1172  *    -    numBiquad < 1
1173  *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1174  *
1175  */
1176 OMXResult omxSP_IIROne_BiQuadDirect_S16 (
1177     OMX_S16 val,
1178     OMX_S16 *pResult,
1179     const OMX_S16 *pTaps,
1180     OMX_INT numBiquad,
1181     OMX_S32 *pDelayLine
1182 );
1183
1184
1185
1186 /**
1187  * Function:  omxSP_IIROne_BiQuadDirect_S16_I   (2.2.3.3.2)
1188  *
1189  * Description:
1190  * Single-sample biquad IIR filtering for 16-bit data type. This function
1191  * applies the direct form II biquad IIR cascade defined by the coefficient
1192  * vector pTaps to a single sample of input data.  The internal accumulator
1193  * width must be at least 32 bits, and the result is saturated if the
1194  * operation produces a value outside the range of a signed 16-bit integer,
1195  * i.e., the output will saturate to 0x8000 (-32768) for a negative overflow
1196  * or 0x7fff (32767) for a positive overflow.  The result is undefined if any
1197  * of the partially accumulated values exceeds the range of a signed 32-bit
1198  * integer.
1199  *
1200  * Input Arguments:
1201  *
1202  *   pValResult - pointer to the single input sample to which the filter is
1203  *            applied.
1204  *   pTaps - pointer to the 6P-element vector that contains the combined
1205  *            numerator and denominator filter coefficients from the biquad
1206  *            cascade. Coefficient scaling and coefficient vector organization
1207  *            should follow the conventions described above. The value of the
1208  *            coefficient scalefactor exponent must be non-negative: (sfp>=0).
1209  *   numBiquad - the number of biquads contained in the IIR filter cascade:
1210  *            (P)
1211  *   pDelayLine - pointer to the 2p-element filter memory buffer (state). The
1212  *            user is responsible for allocation, initialization, and
1213  *            deallocation. The filter memory elements are initialized to zero
1214  *            in most applications.
1215  *
1216  * Output Arguments:
1217  *
1218  *   pValResult - pointer to the filtered output sample
1219  *
1220  * Return Value:
1221  *
1222  *    OMX_Sts_NoErr - no error
1223  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1224  *              following is true:
1225  *    -    one or more of the following pointers is NULL:
1226  *              pValResult, pTaps, or pDelayLine.
1227  *    -    numBiquad < 1
1228  *    -    pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1229  *
1230  */
1231 OMXResult omxSP_IIROne_BiQuadDirect_S16_I (
1232     OMX_S16 *pValResult,
1233     const OMX_S16 *pTaps,
1234     OMX_INT numBiquad,
1235     OMX_S32 *pDelayLine
1236 );
1237
1238
1239
1240 /**
1241  * Function:  omxSP_FilterMedian_S32   (2.2.3.4.1)
1242  *
1243  * Description:
1244  * This function computes the median over the region specified by the median
1245  * mask for the every element of the input array. The median outputs are
1246  * stored in the corresponding elements of the output vector.
1247  *
1248  * Input Arguments:
1249  *
1250  *   pSrc - pointer to the input vector
1251  *   len - number of elements contained in the input and output vectors (0 <
1252  *            len < 65536)
1253  *   maskSize - median mask size; if an even value is specified, the function
1254  *            subtracts 1 and uses the odd value of the filter mask for median
1255  *            filtering (0 < maskSize < 256)
1256  *
1257  * Output Arguments:
1258  *
1259  *   pDst - pointer to the median-filtered output vector
1260  *
1261  * Return Value:
1262  *
1263  *    OMX_Sts_NoErr - no error
1264  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1265  *              following is true:
1266  *    -   one or more of the following pointers is NULL: pSrc, pDst.
1267  *    -    len < 0
1268  *    -    maskSize < 1 or maskSize> 255
1269  *    OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
1270  *              size
1271  *
1272  */
1273 OMXResult omxSP_FilterMedian_S32 (
1274     const OMX_S32 *pSrc,
1275     OMX_S32 *pDst,
1276     OMX_INT len,
1277     OMX_INT maskSize
1278 );
1279
1280
1281
1282 /**
1283  * Function:  omxSP_FilterMedian_S32_I   (2.2.3.4.1)
1284  *
1285  * Description:
1286  * This function computes the median over the region specified by the median
1287  * mask for the every element of the input array. The median outputs are
1288  * stored in the corresponding elements of the output vector.
1289  *
1290  * Input Arguments:
1291  *
1292  *   pSrcDst - pointer to the input vector
1293  *   len - number of elements contained in the input and output vectors (0 <
1294  *            len < 65536)
1295  *   maskSize - median mask size; if an even value is specified, the function
1296  *            subtracts 1 and uses the odd value of the filter mask for median
1297  *            filtering (0 < maskSize < 256)
1298  *
1299  * Output Arguments:
1300  *
1301  *   pSrcDst - pointer to the median-filtered output vector
1302  *
1303  * Return Value:
1304  *
1305  *    OMX_Sts_NoErr - no error
1306  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1307  *              following is true:
1308  *    -    pSrcDst is NULL.
1309  *    -    len < 0
1310  *    -    maskSize < 1 or maskSize> 255
1311  *    OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
1312  *              size
1313  *
1314  */
1315 OMXResult omxSP_FilterMedian_S32_I (
1316     OMX_S32 *pSrcDst,
1317     OMX_INT len,
1318     OMX_INT maskSize
1319 );
1320
1321
1322
1323 /**
1324  * Function:  omxSP_FFTInit_C_SC16   (2.2.4.1.2)
1325  *
1326  * Description:
1327  * These functions initialize the specification structures required for the
1328  * complex FFT and IFFT functions. Desired block length is specified as an
1329  * input. The function <FFTInit_C_SC16> is used to initialize the
1330  * specification structures for functions <FFTFwd_CToC_SC16_Sfs> and
1331  * <FFTInv_CToC_SC16_Sfs>.
1332  *
1333  * Memory for the specification structure *pFFTSpec
1334  * must be allocated prior to calling these functions and should be 4-byte
1335  * aligned for omxSP_FFTInit_C_SC16.
1336  *
1337  * The space required for *pFFTSpec, in bytes, can be
1338  * determined using <FFTGetBufSize_C_SC16>.
1339  *
1340  * Input Arguments:
1341  *
1342  *   order - base-2 logarithm of the desired block length;
1343  *           valid in the range [0,12]
1344  *
1345  * Output Arguments:
1346  *
1347  *   pFFTSpec - pointer to initialized specification structure
1348  *
1349  * Return Value:
1350  *
1351  *    OMX_Sts_NoErr -no error
1352  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1353  *              following is true:
1354  *    -   pFFTSpec is either NULL or violates the 4-byte alignment
1355  *              restrictions
1356  *    -   order < 0 or order > 12
1357  *
1358  */
1359 OMXResult omxSP_FFTInit_C_SC16 (
1360     OMXFFTSpec_C_SC16 *pFFTSpec,
1361     OMX_INT order
1362 );
1363
1364
1365
1366 /**
1367  * Function:  omxSP_FFTInit_C_SC32   (2.2.4.1.2)
1368  *
1369  * Description:
1370  * These functions initialize the specification structures required for the
1371  * complex FFT and IFFT functions. Desired block length is specified as an
1372  * input. The function <FFTInit_C_SC32> is used to initialize
1373  * the specification structures for the functions <FFTFwd_CToC_SC32_Sfs> and
1374  * <FFTInv_CToC_SC32_Sfs>.
1375  *
1376  * Memory for the specification structure *pFFTSpec must be allocated prior
1377  * to calling these functions and should be 8-byte aligned for
1378  * omxSP_FFTInit_C_SC32.
1379  *
1380  * The space required for *pFFTSpec, in bytes, can be
1381  * determined using <FFTGetBufSize_C_SC32>.
1382  *
1383  * Input Arguments:
1384  *
1385  *   order - base-2 logarithm of the desired block length; valid in the range
1386  *            [0,12]
1387  *
1388  * Output Arguments:
1389  *
1390  *   pFFTSpec - pointer to initialized specification structure
1391  *
1392  * Return Value:
1393  *
1394  *    OMX_Sts_NoErr -no error
1395  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1396  *              following is true:
1397  *    -   pFFTSpec is either NULL or violates the 8-byte alignment
1398  *              restrictions
1399  *    -   order < 0 or order > 12
1400  *
1401  */
1402 OMXResult omxSP_FFTInit_C_SC32 (
1403     OMXFFTSpec_C_SC32 *pFFTSpec,
1404     OMX_INT order
1405 );
1406
1407 /**
1408  * Function:  omxSP_FFTInit_C_FC32   (2.2.4.1.2)
1409  *
1410  * Description:
1411  * These functions initialize the specification structures required for the
1412  * complex FFT and IFFT functions. Desired block length is specified as an
1413  * input. The function <FFTInit_C_FC32> is used to initialize
1414  * the specification structures for the functions <FFTFwd_CToC_FC32_Sfs> and
1415  * <FFTInv_CToC_FC32_Sfs>.
1416  *
1417  * Memory for the specification structure *pFFTSpec must be allocated prior
1418  * to calling these functions and should be 8-byte aligned for
1419  * omxSP_FFTInit_C_FC32.
1420  *
1421  * The space required for *pFFTSpec, in bytes, can be
1422  * determined using <FFTGetBufSize_C_FC32>.
1423  *
1424  * Input Arguments:
1425  *
1426  *   order - base-2 logarithm of the desired block length; valid in the range
1427  *            [1,15]
1428  *
1429  * Output Arguments:
1430  *
1431  *   pFFTSpec - pointer to initialized specification structure
1432  *
1433  * Return Value:
1434  *
1435  *    OMX_Sts_NoErr -no error
1436  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1437  *              following is true:
1438  *    -   pFFTSpec is either NULL or violates the 8-byte alignment
1439  *              restrictions
1440  *    -   order < 1 or order > 15
1441  *
1442  */
1443 OMXResult omxSP_FFTInit_C_FC32(
1444     OMXFFTSpec_C_FC32* pFFTSpec,
1445     OMX_INT order
1446 );
1447
1448
1449
1450 /**
1451  * Function:  omxSP_FFTInit_R_S16S32   (2.2.4.1.4)
1452  *
1453  * Description:
1454  * These functions initialize specification structures required for the real
1455  * FFT and IFFT functions. The function <FFTInit_R_S16S32> is used to
1456  * initialize the specification structures for functions
1457  * <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>.
1458  *
1459  * Memory for
1460  * *pFFTFwdSpec must be allocated before calling these functions and should be
1461  * 8-byte aligned. The number of bytes required for *pFFTFwdSpec can be
1462  * determined using <FFTGetBufSize_R_S16S32>.
1463  *
1464  * Input Arguments:
1465  *
1466  *   order - base-2 logarithm of the desired block length; valid in the range
1467  *            [0,12]
1468  *
1469  * Output Arguments:
1470  *
1471  *   pFFTFwdSpec - pointer to the initialized specification structure
1472  *
1473  * Return Value:
1474  *
1475  *    OMX_Sts_NoErr - no error
1476  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1477  *              following is true:
1478  *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
1479  *              restrictions
1480  *    -   order < 0 or order > 12
1481  *
1482  */
1483 OMXResult omxSP_FFTInit_R_S16S32(
1484     OMXFFTSpec_R_S16S32* pFFTFwdSpec,
1485     OMX_INT order
1486 );
1487
1488
1489
1490 /**
1491  * Function:  omxSP_FFTInit_R_S16
1492  *
1493  * Description:
1494  * These functions initialize specification structures required for the real
1495  * FFT and IFFT functions. The function <FFTInit_R_S16> is used
1496  * to initialize the specification structures for functions
1497  * <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>.
1498  *
1499  * Memory for *pFFTFwdSpec must be allocated before calling these functions
1500  * and should be 8-byte aligned.
1501  *
1502  * The number of bytes required for *pFFTFwdSpec can be
1503  * determined using <FFTGetBufSize_R_S16>.
1504  *
1505  * Input Arguments:
1506  *
1507  *   order - base-2 logarithm of the desired block length; valid in the range
1508  *            [1,12]
1509  *
1510  * Output Arguments:
1511  *
1512  *   pFFTFwdSpec - pointer to the initialized specification structure
1513  *
1514  * Return Value:
1515  *
1516  *    OMX_Sts_NoErr - no error
1517  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1518  *              following is true:
1519  *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
1520  *              restrictions
1521  *    -   order < 1 or order > 12
1522  *
1523  */
1524 OMXResult omxSP_FFTInit_R_S16 (
1525     OMXFFTSpec_R_S32*pFFTFwdSpec,
1526     OMX_INT order
1527 );
1528
1529 /**
1530  * Function:  omxSP_FFTInit_R_S32   (2.2.4.1.4)
1531  *
1532  * Description:
1533  * These functions initialize specification structures required for the real
1534  * FFT and IFFT functions. The function <FFTInit_R_S32> is used to initialize
1535  * the specification structures for functions <FFTFwd_RToCCS_S32_Sfs>
1536  * and <FFTInv_CCSToR_S32_Sfs>.
1537  *
1538  * Memory for *pFFTFwdSpec must be allocated before calling these functions
1539  * and should be 8-byte aligned.
1540  *
1541  * The number of bytes required for *pFFTFwdSpec can be
1542  * determined using <FFTGetBufSize_R_S32>.
1543  *
1544  * Input Arguments:
1545  *
1546  *   order - base-2 logarithm of the desired block length; valid in the range
1547  *            [0,12]
1548  *
1549  * Output Arguments:
1550  *
1551  *   pFFTFwdSpec - pointer to the initialized specification structure
1552  *
1553  * Return Value:
1554  *
1555  *    OMX_Sts_NoErr - no error
1556  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1557  *              following is true:
1558  *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
1559  *              restrictions
1560  *    -   order < 0 or order > 12
1561  *
1562  */
1563 OMXResult omxSP_FFTInit_R_S32 (
1564     OMXFFTSpec_R_S32*pFFTFwdSpec,
1565     OMX_INT order
1566 );
1567
1568 /**
1569  * Function:  omxSP_FFTInit_R_F32
1570  *
1571  * Description:
1572  * These functions initialize specification structures required for the real
1573  * FFT and IFFT functions. The function <FFTInit_R_F32> is used to initialize
1574  * the specification structures for functions <FFTFwd_RToCCS_F32_Sfs>
1575  * and <FFTInv_CCSToR_F32_Sfs>.
1576  *
1577  * Memory for *pFFTFwdSpec must be allocated before calling these functions
1578  * and should be 8-byte aligned.
1579  *
1580  * The number of bytes required for *pFFTFwdSpec can be
1581  * determined using <FFTGetBufSize_R_F32>.
1582  *
1583  * Input Arguments:
1584  *
1585  *   order - base-2 logarithm of the desired block length; valid in the range
1586  *            [1,15]
1587  *
1588  * Output Arguments:
1589  *
1590  *   pFFTFwdSpec - pointer to the initialized specification structure
1591  *
1592  * Return Value:
1593  *
1594  *    OMX_Sts_NoErr - no error
1595  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1596  *              following is true:
1597  *    -   pFFTFwdSpec is either NULL or violates the 8-byte alignment
1598  *              restrictions
1599  *    -   order < 1 or order > 15
1600  *
1601  */
1602 OMXResult omxSP_FFTInit_R_F32(
1603     OMXFFTSpec_R_F32* pFFTFwdSpec,
1604     OMX_INT order
1605 );
1606
1607 /**
1608  * Function:  omxSP_FFTGetBufSize_C_SC16   (2.2.4.1.6)
1609  *
1610  * Description:
1611  * These functions compute the size of the specification structure
1612  * required for the length 2^order complex FFT and IFFT functions. The function
1613  * <FFTGetBufSize_C_SC16> is used in conjunction with the 16-bit functions
1614  * <FFTFwd_CToC_SC16_Sfs> and <FFTInv_CToC_SC16_Sfs>.
1615  *
1616  * Input Arguments:
1617  *
1618  *   order - base-2 logarithm of the desired block length; valid in the range
1619  *            [0,12]
1620  *
1621  * Output Arguments:
1622  *
1623  *   pSize - pointer to the number of bytes required for the specification
1624  *            structure
1625  *
1626  * Return Value:
1627  *
1628  *    OMX_Sts_NoErr - no error
1629  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1630  *              following is true:
1631  *    -    pSize is NULL
1632  *    -    order < 0 or order > 12
1633  *
1634  */
1635 OMXResult omxSP_FFTGetBufSize_C_SC16 (
1636     OMX_INT order,
1637     OMX_INT *pSize
1638 );
1639
1640
1641
1642 /**
1643  * Function:  omxSP_FFTGetBufSize_C_SC32   (2.2.4.1.6)
1644  *
1645  * Description:
1646  * These functions compute the size of the specification structure
1647  * required for the length 2^order complex FFT and IFFT functions. The function
1648  * <FFTGetBufSize_C_SC32> is used in conjunction with the 32-bit functions
1649  * <FFTFwd_CToC_SC32_Sfs> and <FFTInv_CToC_SC32_Sfs>.
1650  *
1651  * Input Arguments:
1652  *
1653  *   order - base-2 logarithm of the desired block length; valid in the range
1654  *            [0,12]
1655  *
1656  * Output Arguments:
1657  *
1658  *   pSize - pointer to the number of bytes required for the specification
1659  *            structure
1660  *
1661  * Return Value:
1662  *
1663  *    OMX_Sts_NoErr - no error
1664  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1665  *              following is true:
1666  *    -    pSize is NULL
1667  *    -    order < 0 or order > 12
1668  *
1669  */
1670 OMXResult omxSP_FFTGetBufSize_C_SC32 (
1671     OMX_INT order,
1672     OMX_INT *pSize
1673 );
1674
1675 /**
1676  * Function:  omxSP_FFTGetBufSize_C_FC32
1677  *
1678  * Description:
1679  * These functions compute the size of the specification structure
1680  * required for the length 2^order complex FFT and IFFT functions. The function
1681  * <FFTGetBufSize_C_FC32> is used in conjunction with the 32-bit functions
1682  * <FFTFwd_CToC_FC32_Sfs> and <FFTInv_CToC_FC32_Sfs>.
1683  *
1684  * Input Arguments:
1685  *
1686  *   order - base-2 logarithm of the desired block length; valid in the range
1687  *            [1,15]
1688  *
1689  * Output Arguments:
1690  *
1691  *   pSize - pointer to the number of bytes required for the specification
1692  *            structure
1693  *
1694  * Return Value:
1695  *
1696  *    OMX_Sts_NoErr - no error
1697  *    OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1698  *              following is true:
1699  *    -    pSize is NULL
1700  *    -    order < 1 or order > 15
1701  *
1702  */
1703 OMXResult omxSP_FFTGetBufSize_C_FC32(
1704     OMX_INT order,
1705     OMX_INT* pSize
1706 );
1707
1708
1709 /**
1710  * Function:  omxSP_FFTGetBufSize_R_S16S32   (2.2.4.1.8)
1711  *
1712  * Description:
1713  * order These functions compute the size of the specification structure
1714  * required for the length 2^order real FFT and IFFT functions. The function
1715  * <FFTGetBufSize_R_S16S32> is used in conjunction with the 16-bit functions
1716  * <FFTFwd_RToCCS_S16S32_Sfs> and <FFTInv_CCSToR_S32S16_Sfs>.
1717  *
1718  * Input Arguments:
1719  *
1720  *   order - base-2 logarithm of the length; valid in the range [0,12]
1721  *
1722  * Output Arguments:
1723  *
1724  *   pSize - pointer to the number of bytes required for the specification
1725  *            structure
1726  *
1727  * Return Value:
1728  *
1729  *    OMX_Sts_NoErr - no error
1730  *    OMX_Sts_BadArgErr - bad arguments The function returns
1731  *              OMX_Sts_BadArgErr if one or more of the following is true:
1732  *    pSize is NULL
1733  *    order < 0 or order > 12
1734  *
1735  */
1736 OMXResult omxSP_FFTGetBufSize_R_S16S32(
1737     OMX_INT order,
1738     OMX_INT* pSize
1739 );
1740
1741
1742 /**
1743  * Function:  omxSP_FFTGetBufSize_R_S16
1744  *
1745  * Description:
1746  * These functions compute the size of the specification structure
1747  * required for the length 2^order real FFT and IFFT functions.  The function
1748  * <FFTGetBufSize_R_S16> is used in conjunction with the 16-bit
1749  * functions <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>.
1750  *
1751  * Input Arguments:
1752  *
1753  *   order - base-2 logarithm of the length; valid in the range
1754  *   [1,12]
1755  *
1756  * Output Arguments:
1757  *
1758  *   pSize - pointer to the number of bytes required for the specification
1759  *            structure
1760  *
1761  * Return Value:
1762  *
1763  *    OMX_Sts_NoErr - no error
1764  *    OMX_Sts_BadArgErr - bad arguments The function returns
1765  *              OMX_Sts_BadArgErr if one or more of the following is true:
1766  *    pSize is NULL
1767  *    order < 1 or order > 12
1768  *
1769  */
1770 OMXResult omxSP_FFTGetBufSize_R_S16 (
1771     OMX_INT order,
1772     OMX_INT *pSize
1773 );
1774
1775 /**
1776  * Function:  omxSP_FFTGetBufSize_R_S32   (2.2.4.1.8)
1777  *
1778  * Description:
1779  * These functions compute the size of the specification structure
1780  * required for the length 2^order real FFT and IFFT functions.  The function
1781  * <FFTGetBufSize_R_S32> is used in conjunction with the 32-bit functions
1782  * <FFTFwd_RToCCS_S32_Sfs> and <FFTInv_CCSToR_S32_Sfs>.
1783  *
1784  * Input Arguments:
1785  *
1786  *   order - base-2 logarithm of the length; valid in the range [0,12]
1787  *
1788  * Output Arguments:
1789  *
1790  *   pSize - pointer to the number of bytes required for the specification
1791  *            structure
1792  *
1793  * Return Value:
1794  *
1795  *    OMX_Sts_NoErr - no error
1796  *    OMX_Sts_BadArgErr - bad arguments The function returns
1797  *              OMX_Sts_BadArgErr if one or more of the following is true:
1798  *    pSize is NULL
1799  *    order < 0 or order > 12
1800  *
1801  */
1802 OMXResult omxSP_FFTGetBufSize_R_S32 (
1803     OMX_INT order,
1804     OMX_INT *pSize
1805 );
1806
1807 /**
1808  * Function:  omxSP_FFTGetBufSize_R_F32
1809  *
1810  * Description:
1811  * These functions compute the size of the specification structure
1812  * required for the length 2^order real FFT and IFFT functions.  The function
1813  * <FFTGetBufSize_R_F32> is used in conjunction with the 32-bit functions
1814  * <FFTFwd_RToCCS_F32_Sfs> and <FFTInv_CCSToR_F32_Sfs>.
1815  *
1816  * Input Arguments:
1817  *
1818  *   order - base-2 logarithm of the length; valid in the range [1,15]
1819  *
1820  * Output Arguments:
1821  *
1822  *   pSize - pointer to the number of bytes required for the specification
1823  *            structure
1824  *
1825  * Return Value:
1826  *
1827  *    OMX_Sts_NoErr - no error
1828  *    OMX_Sts_BadArgErr - bad arguments The function returns
1829  *              OMX_Sts_BadArgErr if one or more of the following is true:
1830  *    pSize is NULL
1831  *    order < 1 or order > 15
1832  *
1833  */
1834 OMXResult omxSP_FFTGetBufSize_R_F32(
1835     OMX_INT order,
1836     OMX_INT* pSize
1837 );
1838
1839
1840
1841 /**
1842  * Function:  omxSP_FFTFwd_CToC_SC16_Sfs   (2.2.4.2.2)
1843  *
1844  * Description:
1845  * Compute an FFT for a complex signal of length of 2^order,
1846  * where 0 <= order <= 12.
1847  * Transform length is determined by the specification structure, which
1848  * must be initialized prior to calling the FFT function using the appropriate
1849  * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
1850  * between the input and output sequences can be expressed in terms of the
1851  * DFT, i.e.,
1852  *
1853  *      X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
1854  *      k = 0,1,2,..., N-1
1855  *      N = 2^order
1856  *
1857  * Input Arguments:
1858  *   pSrc - pointer to the input signal, a complex-valued vector of length 2^order;
1859  *            must be aligned on a 32 byte boundary.
1860  *   pFFTSpec - pointer to the preallocated and initialized specification
1861  *            structure
1862  *   scaleFactor - output scale factor; the range for is [0,16]
1863  *
1864  * Output Arguments:
1865  *   pDst - pointer to the complex-valued output vector, of length 2^order;
1866  *          must be aligned on an 32-byte boundary.
1867  *
1868  * Return Value:
1869  *
1870  *    OMX_Sts_NoErr - no error
1871  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
1872  *              is true:
1873  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
1874  *              pFFTSpec.
1875  *    -    pSrc or pDst is not 32-byte aligned
1876  *    -    scaleFactor<0 or scaleFactor>16
1877  *
1878  */
1879
1880 OMXResult omxSP_FFTFwd_CToC_SC16_Sfs (
1881     const OMX_SC16 *pSrc,
1882     OMX_SC16 *pDst,
1883     const OMXFFTSpec_C_SC16 *pFFTSpec,
1884     OMX_INT scaleFactor
1885 );
1886
1887 OMXResult omxSP_FFTFwd_CToC_SC16_Sfs_neon (
1888     const OMX_SC16 *pSrc,
1889     OMX_SC16 *pDst,
1890     const OMXFFTSpec_C_SC16 *pFFTSpec,
1891     OMX_INT scaleFactor
1892 );
1893
1894 /**
1895  * Function:  omxSP_FFTFwd_CToC_SC32_Sfs   (2.2.4.2.2)
1896  *
1897  * Description:
1898  * Compute an FFT for a complex signal of length of 2^order,
1899  * where 0 <= order <= 12.
1900  * Transform length is determined by the specification structure, which
1901  * must be initialized prior to calling the FFT function using the appropriate
1902  * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
1903  * between the input and output sequences can be expressed in terms of the
1904  * DFT, i.e.,
1905  *
1906  *      X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
1907  *      k = 0,1,2,..., N-1
1908  *      N = 2^order
1909  *
1910  * Input Arguments:
1911  *   pSrc - pointer to the input signal, a complex-valued vector of length 2^order;
1912  *            must be aligned on a 32 byte boundary.
1913  *   pFFTSpec - pointer to the preallocated and initialized specification
1914  *            structure
1915  *   scaleFactor - output scale factor; the range is [0,32]
1916  *
1917  * Output Arguments:
1918  *   pDst - pointer to the complex-valued output vector, of length 2^order; must be
1919  *            aligned on an 32-byte boundary.
1920  *
1921  * Return Value:
1922  *
1923  *    OMX_Sts_NoErr - no error
1924  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
1925  *              is true:
1926  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
1927  *              pFFTSpec.
1928  *    -    pSrc or pDst is not 32-byte aligned
1929  *    -    scaleFactor<0 or scaleFactor >32
1930  *
1931  */
1932 OMXResult omxSP_FFTFwd_CToC_SC32_Sfs (
1933     const OMX_SC32 *pSrc,
1934     OMX_SC32 *pDst,
1935     const OMXFFTSpec_C_SC32 *pFFTSpec,
1936     OMX_INT scaleFactor
1937 );
1938
1939
1940
1941 /**
1942  * Function:  omxSP_FFTInv_CToC_SC16_Sfs   (2.2.4.2.4)
1943  *
1944  * Description:
1945  * These functions compute an inverse FFT for a complex signal of  length
1946  * of 2^order, where 0 <= order <= 12. Transform length is determined by the
1947  * specification structure, which must be initialized prior to calling the FFT
1948  * function using the appropriate helper, i.e., <FFTInit_C_sc32> or
1949  * <FFTInit_C_SC16>. The relationship between the input and output sequences
1950  * can be expressed in terms of the IDFT, i.e.:
1951  *
1952  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
1953  *     n=0,1,2,...N-1
1954  *     N=2^order.
1955  *
1956  * Input Arguments:
1957  *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
1958  *          must be aligned on a 32-byte boundary.
1959  *   pFFTSpec - pointer to the preallocated and initialized specification
1960  *            structure
1961  *   scaleFactor - scale factor of the output. Valid range is [0,16].
1962  *
1963  * Output Arguments:
1964  *   order
1965  *   pDst - pointer to the complex-valued output signal, of length 2^order;
1966  *          must be aligned on a 32-byte boundary.
1967  *
1968  * Return Value:
1969  *
1970  *    Positive value - the shift scale that was performed inside
1971  *    OMX_Sts_NoErr - no error
1972  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
1973  *              is true:
1974  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
1975  *              pFFTSpec.
1976  *    -   pSrc or pDst is not 32-byte aligned
1977  *    -   scaleFactor<0 or scaleFactor>16
1978  *
1979  */
1980 OMXResult omxSP_FFTInv_CToC_SC16_Sfs (
1981     const OMX_SC16 *pSrc,
1982     OMX_SC16 *pDst,
1983     const OMXFFTSpec_C_SC16 *pFFTSpec,
1984     OMX_INT scaleFactor
1985 );
1986
1987 OMXResult omxSP_FFTInv_CToC_SC16_Sfs_neon (
1988     const OMX_SC16 *pSrc,
1989     OMX_SC16 *pDst,
1990     const OMXFFTSpec_C_SC16 *pFFTSpec,
1991     OMX_INT scaleFactor
1992 );
1993
1994
1995
1996
1997 /**
1998  * Function:  omxSP_FFTInv_CToC_SC32_Sfs   (2.2.4.2.4)
1999  *
2000  * Description:
2001  * These functions compute an inverse FFT for a complex signal of length
2002  * of 2^order, where 0 <= order <= 12. Transform length is determined by the
2003  * specification structure, which must be initialized prior to calling the FFT
2004  * function using the appropriate helper, i.e., <FFTInit_C_sc32> or
2005  * <FFTInit_C_SC16>. The relationship between the input and output sequences
2006  * can be expressed in terms of the IDFT, i.e.:
2007  *
2008  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2009  *     n=0,1,2,...N-1
2010  *     N=2^order.
2011  *
2012  * Input Arguments:
2013  *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
2014  *          must be aligned on a 32-byte boundary.
2015  *   pFFTSpec - pointer to the preallocated and initialized specification
2016  *            structure
2017  *   scaleFactor - scale factor of the output. Valid range is [0,32].
2018  *
2019  * Output Arguments:
2020  *   order
2021  *   pDst - pointer to the complex-valued output signal, of length 2^order;
2022  *          must be aligned on a 32-byte boundary.
2023  *
2024  * Return Value:
2025  *
2026  *    OMX_Sts_NoErr - no error
2027  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
2028  *              is true:
2029  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
2030  *              pFFTSpec.
2031  *    -   pSrc or pDst is not 32-byte aligned
2032  *    -   scaleFactor<0 or scaleFactor>32
2033  *
2034  */
2035 OMXResult omxSP_FFTInv_CToC_SC32_Sfs (
2036     const OMX_SC32 *pSrc,
2037     OMX_SC32 *pDst,
2038     const OMXFFTSpec_C_SC32 *pFFTSpec,
2039     OMX_INT scaleFactor
2040 );
2041
2042
2043
2044 /**
2045  * Function:  omxSP_FFTFwd_RToCCS_S16S32_Sfs   (2.2.4.4.2)
2046  *
2047  * Description:
2048  * These functions compute an FFT for a real-valued signal of length of 2^order,
2049  * where 0 <= order <= 12. Transform length is determined by the
2050  * specification structure, which must be initialized prior to calling the FFT
2051  * function using the appropriate helper, i.e., <FFTInit_R_S16S32>.
2052  * The relationship between the input and output sequences
2053  * can be expressed in terms of the DFT, i.e.:
2054  *
2055  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2056  *     n=0,1,2,...N-1
2057  *     N=2^order.
2058  *
2059  * The conjugate-symmetric output sequence is represented using a CCS vector,
2060  * which is of length N+2, and is organized as follows:
2061  *
2062  *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
2063  *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
2064  *
2065  * where R[n] and I[n], respectively, denote the real and imaginary components
2066  * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
2067  * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the
2068  * foldover frequency.
2069  *
2070  * Input Arguments:
2071  *   pSrc - pointer to the real-valued input sequence, of length 2^order;
2072  *          must be aligned on a 32-byte boundary.
2073  *   pFFTSpec - pointer to the preallocated and initialized specification
2074  *            structure
2075  *   scaleFactor - output scale factor; valid range is [0, 32]
2076  *
2077  * Output Arguments:
2078  *   pDst - pointer to output sequence, represented using CCS format, of
2079  *            length (2^order)+2; must be aligned on a 32-byte boundary.
2080  *
2081  * Return Value:
2082  *
2083  *    OMX_Sts_NoErr - no error
2084  *    OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true:
2085  *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
2086  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2087  *    -    scaleFactor<0 or scaleFactor >32
2088  *
2089  */
2090 OMXResult omxSP_FFTFwd_RToCCS_S16S32_Sfs (
2091     const OMX_S16 *pSrc,
2092     OMX_S32 *pDst,
2093     const OMXFFTSpec_R_S16S32 *pFFTSpec,
2094     OMX_INT scaleFactor
2095 );
2096
2097
2098 /**
2099  * Function:  omxSP_FFTFwd_RToCCS_S16_Sfs
2100  *
2101  * Description:
2102  * These functions compute an FFT for a real-valued signal of length of 2^order,
2103  * where 0 < order <= 12. Transform length is determined by the
2104  * specification structure, which must be initialized prior to calling the FFT
2105  * function using the appropriate helper, i.e., <FFTInit_R_S16>.
2106  * The relationship between the input and output sequences can
2107  * be expressed in terms of the DFT, i.e.:
2108  *
2109  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2110  *     n=0,1,2,...N-1
2111  *     N=2^order.
2112  *
2113  * The conjugate-symmetric output sequence is represented using a CCS vector,
2114  * which is of length N+2, and is organized as follows:
2115  *
2116  *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
2117  *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
2118  *
2119  * where R[n] and I[n], respectively, denote the real and imaginary components
2120  * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
2121  * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to
2122  * the foldover frequency.
2123  *
2124  * Input Arguments:
2125  *   pSrc - pointer to the real-valued input sequence, of length 2^order;
2126  *          must be aligned on a 32-byte boundary.
2127  *   pFFTSpec - pointer to the preallocated and initialized specification
2128  *            structure
2129  *   scaleFactor - output scale factor; valid range is [0, 16]
2130  *
2131  * Output Arguments:
2132  *   pDst - pointer to output sequence, represented using CCS format, of
2133  *            length (2^order)+2; must be aligned on a 32-byte boundary.
2134  *
2135  * Return Value:
2136  *
2137  *    OMX_Sts_NoErr - no error
2138  *    OMX_Sts_BadArgErr - bad arguments, if one or more of followings is true:
2139  *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
2140  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2141  *    -    scaleFactor<0 or scaleFactor >16
2142  *
2143  */
2144 OMXResult omxSP_FFTFwd_RToCCS_S16_Sfs (
2145     const OMX_S16* pSrc,
2146     OMX_S16* pDst,
2147     const OMXFFTSpec_R_S16* pFFTSpec,
2148     OMX_INT scaleFactor
2149 );
2150
2151
2152 /**
2153  * Function:  omxSP_FFTFwd_RToCCS_S32_Sfs   (2.2.4.4.2)
2154  *
2155  * Description:
2156  * These functions compute an FFT for a real-valued signal of length of 2^order,
2157  * where 0 <= order <= 12. Transform length is determined by the
2158  * specification structure, which must be initialized prior to calling the FFT
2159  * function using the appropriate helper, i.e., <FFTInit_R_S32>.
2160  * The relationship between the input and output sequences
2161  * can be expressed in terms of the DFT, i.e.:
2162  *
2163  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2164  *     n=0,1,2,...N-1
2165  *     N=2^order.
2166  *
2167  * The conjugate-symmetric output sequence is represented using a CCS vector,
2168  * which is of length N+2, and is organized as follows:
2169  *
2170  *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
2171  *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
2172  *
2173  * where R[n] and I[n], respectively, denote the real and imaginary components
2174  * for FFT bin 'n'. Bins  are numbered from 0 to N/2, where N is the FFT length.
2175  * Bin index 0 corresponds to the DC component, and bin index N/2 corresponds to the
2176  * foldover frequency.
2177  *
2178  * Input Arguments:
2179  *   pSrc - pointer to the real-valued input sequence, of length 2^order;
2180  *          must be aligned on a 32-byte boundary.
2181  *   pFFTSpec - pointer to the preallocated and initialized specification
2182  *            structure
2183  *   scaleFactor - output scale factor; valid range is [0, 32]
2184  *
2185  * Output Arguments:
2186  *   pDst - pointer to output sequence, represented using CCS format, of
2187  *            length (2^order)+2; must be aligned on a 32-byte boundary.
2188  *
2189  * Return Value:
2190  *
2191  *    OMX_Sts_NoErr - no error
2192  *    OMX_Sts_BadArgErr - bad arguments, if one or more of the following is true:
2193  *    -    one of the pointers pSrc, pDst, or pFFTSpec is NULL
2194  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2195  *    -    scaleFactor<0 or scaleFactor >32
2196  *
2197  */
2198 OMXResult omxSP_FFTFwd_RToCCS_S32_Sfs (
2199     const OMX_S32 *pSrc,
2200     OMX_S32 *pDst,
2201     const OMXFFTSpec_R_S32 *pFFTSpec,
2202     OMX_INT scaleFactor
2203 );
2204
2205 /**
2206  * Function:  omxSP_FFTFwd_CToC_FC32_Sfs   (2.2.4.2.2)
2207  *
2208  * Description:
2209  * Compute an FFT for a complex signal of length of 2^order,
2210  * where 0 <= order <= 15.
2211  * Transform length is determined by the specification structure, which
2212  * must be initialized prior to calling the FFT function using the appropriate
2213  * helper, i.e., <FFTInit_C_sc32> or <FFTInit_C_SC16>. The relationship
2214  * between the input and output sequences can be expressed in terms of the
2215  * DFT, i.e.,
2216  *
2217  *      X[k] = SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
2218  *      k = 0,1,2,..., N-1
2219  *      N = 2^order
2220  *
2221  * Input Arguments:
2222  *   pSrc - pointer to the input signal, a complex-valued vector of length
2223  *            2^order; must be aligned on a 32 byte boundary.
2224  *   pFFTSpec - pointer to the preallocated and initialized specification
2225  *            structure
2226  *
2227  * Output Arguments:
2228  *   pDst - pointer to the complex-valued output vector, of length 2^order;
2229  *            must be aligned on an 32-byte boundary.
2230  *
2231  * Return Value:
2232  *
2233  *    OMX_Sts_NoErr - no error
2234  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
2235  *              is true:
2236  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
2237  *              pFFTSpec.
2238  *    -    pSrc or pDst is not 32-byte aligned
2239  *    -    scaleFactor<0 or scaleFactor >32
2240  *
2241  */
2242 OMXResult omxSP_FFTFwd_CToC_FC32_Sfs (
2243     const OMX_FC32 *pSrc,
2244     OMX_FC32 *pDst,
2245     const OMXFFTSpec_C_FC32 *pFFTSpec
2246 );
2247
2248 /**
2249  * Function:  omxSP_FFTFwd_RToCCS_F32_Sfs
2250  *
2251  * Description:
2252  * These functions compute an FFT for a real-valued signal of length
2253  * of 2^order, where 0 <= order <= 12. Transform length is determined
2254  * by the specification structure, which must be initialized prior to
2255  * calling the FFT function using the appropriate helper, i.e.,
2256  * <FFTInit_R_F32>. The relationship between the input and output
2257  * sequences can be expressed in terms of the DFT, i.e.:
2258  *
2259  *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2260  *     n=0,1,2,...N-1
2261  *     N=2^order.
2262  *
2263  * The conjugate-symmetric output sequence is represented using a CCS vector,
2264  * which is of length N+2, and is organized as follows:
2265  *
2266  *   Index:      0  1  2  3  4  5   . . .   N-2       N-1       N       N+1
2267  *   Component:  R0 0  R1 I1 R2 I2  . . .   R[N/2-1]  I[N/2-1]  R[N/2]  0
2268  *
2269  * where R[n] and I[n], respectively, denote the real and imaginary
2270  * components for FFT bin 'n'. Bins are numbered from 0 to N/2, where
2271  * N is the FFT length. Bin index 0 corresponds to the DC component,
2272  * and bin index N/2 corresponds to the foldover frequency.
2273  *
2274  * Input Arguments:
2275  *   pSrc - pointer to the real-valued input sequence, of length 2^order;
2276  *          must be aligned on a 32-byte boundary.
2277  *   pFFTSpec - pointer to the preallocated and initialized specification
2278  *            structure
2279  *
2280  * Output Arguments:
2281  *   pDst - pointer to output sequence, represented using CCS format, of
2282  *            length (2^order)+2; must be aligned on a 32-byte boundary.
2283  *
2284  * Return Value:
2285  *
2286  *    OMX_Sts_NoErr - no error
2287
2288  *    OMX_Sts_BadArgErr - bad arguments, if one or more of the
2289  *    following is true: - one of the pointers pSrc, pDst, or pFFTSpec
2290  *    is NULL - pSrc or pDst is not aligned on a 32-byte boundary
2291  *
2292  */
2293 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs(
2294     const OMX_F32* pSrc,
2295     OMX_F32* pDst,
2296     const OMXFFTSpec_R_F32* pFFTSpec
2297 );
2298
2299 /**
2300  * Function:  omxSP_FFTInv_CCSToR_S32S16_Sfs   (2.2.4.4.4)
2301  *
2302  * Description:
2303  * These functions compute the inverse FFT for a conjugate-symmetric input
2304  * sequence.  Transform length is determined by the specification structure,
2305  * which must be initialized prior to calling the FFT function using
2306  * <FFTInit_R_S16S32>. For a transform of length M, the input sequence is
2307  * represented using a packed CCS vector of length M+2, and is organized
2308  * as follows:
2309  *
2310  *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
2311  *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
2312  *
2313  * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n.
2314  * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
2315  * corresponds to the DC component, and bin index M/2 corresponds to the
2316  * foldover frequency.
2317  *
2318  * Input Arguments:
2319  *   pSrc - pointer to the complex-valued input sequence represented using
2320  *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
2321  *            boundary.
2322  *   pFFTSpec - pointer to the preallocated and initialized specification
2323  *            structure
2324  *   scaleFactor - output scalefactor; range is [0,16]
2325  *
2326  * Output Arguments:
2327  *   pDst - pointer to the real-valued output sequence, of length 2^order ; must be
2328  *            aligned on a 32-byte boundary.
2329  *
2330  * Return Value:
2331  *
2332  *    OMX_Sts_NoErr - no error
2333  *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
2334  *    -    pSrc, pDst, or pFFTSpec is NULL
2335  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2336  *    -    scaleFactor<0 or scaleFactor >16
2337  *
2338  */
2339 OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs (
2340     const OMX_S32 *pSrc,
2341     OMX_S16 *pDst,
2342     const OMXFFTSpec_R_S16S32 *pFFTSpec,
2343     OMX_INT scaleFactor
2344 );
2345
2346
2347 /**
2348  * Function:  omxSP_FFTInv_CCSToR_S16_Sfs
2349  *
2350  * Description:
2351  * These functions compute the inverse FFT for a conjugate-symmetric input
2352  * sequence.  Transform length is determined by the specification structure,
2353  * which must be initialized prior to calling the FFT function using
2354  * <FFTInit_R_S16>. For a transform of length M, the input
2355  * sequence is represented using a packed CCS vector of length
2356  * M+2, and is organized as follows:
2357  *
2358  *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
2359  *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
2360  *
2361  * where R[n] and I[n], respectively, denote the real and imaginary components
2362  * for FFT bin n.
2363  * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
2364  * corresponds to the DC component, and bin index M/2 corresponds to the
2365  * foldover frequency.
2366  *
2367  * Input Arguments:
2368  *   pSrc - pointer to the complex-valued input sequence represented using
2369  *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
2370  *            boundary.
2371  *   pFFTSpec - pointer to the preallocated and initialized specification
2372  *            structure
2373  *   scaleFactor - output scalefactor; range is [0,16]
2374  *
2375  * Output Arguments:
2376  *   pDst - pointer to the real-valued output sequence, of length 2^order ; must
2377  *            be aligned on a 32-byte boundary.
2378  *
2379  * Return Value:
2380  *
2381  *    OMX_Sts_NoErr - no error
2382  *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
2383  *    -    pSrc, pDst, or pFFTSpec is NULL
2384  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2385  *    -    scaleFactor<0 or scaleFactor >16
2386  *
2387  */
2388 OMXResult omxSP_FFTInv_CCSToR_S16_Sfs (
2389     const OMX_S16* pSrc,
2390     OMX_S16* pDst,
2391     const OMXFFTSpec_R_S16* pFFTSpec,
2392     OMX_INT scaleFactor
2393 );
2394
2395 /**
2396  * Function:  omxSP_FFTInv_CCSToR_S32_Sfs   (2.2.4.4.4)
2397  *
2398  * Description:
2399  * These functions compute the inverse FFT for a conjugate-symmetric input
2400  * sequence.  Transform length is determined by the specification structure,
2401  * which must be initialized prior to calling the FFT function using
2402  * <FFTInit_R_S32>. For a transform of length M, the input sequence is
2403  * represented using a packed CCS vector of length M+2, and is organized
2404  * as follows:
2405  *
2406  *   Index:     0    1  2    3    4    5    . . .  M-2       M-1      M      M+1
2407  *   Component  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
2408  *
2409  * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n.
2410  * Bins are numbered from 0 to M/2, where M is the FFT length.  Bin index 0
2411  * corresponds to the DC component, and bin index M/2 corresponds to the
2412  * foldover frequency.
2413  *
2414  * Input Arguments:
2415  *   pSrc - pointer to the complex-valued input sequence represented using
2416  *            CCS format, of length (2^order) + 2; must be aligned on a 32-byte
2417  *            boundary.
2418  *   pFFTSpec - pointer to the preallocated and initialized specification
2419  *            structure
2420  *   scaleFactor - output scalefactor; range is [0,32]
2421  *
2422  * Output Arguments:
2423  *   pDst - pointer to the real-valued output sequence, of length 2^order ; must be
2424  *            aligned on a 32-byte boundary.
2425  *
2426  * Return Value:
2427  *
2428  *    OMX_Sts_NoErr - no error
2429  *    OMX_Sts_BadArgErr - bad arguments if one or more of the following is true:
2430  *    -    pSrc, pDst, or pFFTSpec is NULL
2431  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2432  *    -    scaleFactor<0 or scaleFactor >32
2433  *
2434  */
2435 OMXResult omxSP_FFTInv_CCSToR_S32_Sfs (
2436     const OMX_S32 *pSrc,
2437     OMX_S32 *pDst,
2438     const OMXFFTSpec_R_S32 *pFFTSpec,
2439     OMX_INT scaleFactor
2440 );
2441
2442 /**
2443  * Function:  omxSP_FFTInv_CToC_FC32_Sfs   (2.2.4.2.4)
2444  *
2445  * Description:
2446  * These functions compute an inverse FFT for a complex signal of
2447  * length of 2^order, where 0 <= order <= 15. Transform length is
2448  * determined by the specification structure, which must be
2449  * initialized prior to calling the FFT function using the appropriate
2450  * helper, i.e., <FFTInit_C_FC32>. The relationship between the input
2451  * and output sequences can be expressed in terms of the IDFT, i.e.:
2452  *
2453  *     x[n] = SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2454  *     n=0,1,2,...N-1
2455  *     N=2^order.
2456  *
2457  * Input Arguments:
2458  *   pSrc - pointer to the complex-valued input signal, of length 2^order ;
2459  *          must be aligned on a 32-byte boundary.
2460  *   pFFTSpec - pointer to the preallocated and initialized specification
2461  *            structure
2462  *
2463  * Output Arguments:
2464  *   order
2465  *   pDst - pointer to the complex-valued output signal, of length 2^order;
2466  *          must be aligned on a 32-byte boundary.
2467  *
2468  * Return Value:
2469  *
2470  *    OMX_Sts_NoErr - no error
2471  *    OMX_Sts_BadArgErr - returned if one or more of the following conditions
2472  *              is true:
2473  *    -   one or more of the following pointers is NULL: pSrc, pDst, or
2474  *              pFFTSpec.
2475  *    -   pSrc or pDst is not 32-byte aligned
2476  *    -   scaleFactor<0 or scaleFactor>32
2477  *
2478  */
2479 OMXResult omxSP_FFTInv_CToC_FC32_Sfs (
2480     const OMX_FC32 *pSrc,
2481     OMX_FC32 *pDst,
2482     const OMXFFTSpec_C_FC32 *pFFTSpec
2483 );
2484
2485 /**
2486  * Function:  omxSP_FFTInv_CCSToR_F32_Sfs
2487  *
2488  * Description:
2489  * These functions compute the inverse FFT for a conjugate-symmetric input
2490  * sequence.  Transform length is determined by the specification structure,
2491  * which must be initialized prior to calling the FFT function using
2492  * <FFTInit_R_F32>. For a transform of length M, the input sequence is
2493  * represented using a packed CCS vector of length M+2, and is organized
2494  * as follows:
2495  *
2496  *   Index:   0  1  2    3    4    5    . . .  M-2       M-1      M      M+1
2497  *   Comp:  R[0] 0  R[1] I[1] R[2] I[2] . . .  R[M/2-1]  I[M/2-1] R[M/2] 0
2498  *
2499  * where R[n] and I[n], respectively, denote the real and imaginary
2500  * components for FFT bin n. Bins are numbered from 0 to M/2, where M
2501  * is the FFT length.  Bin index 0 corresponds to the DC component,
2502  * and bin index M/2 corresponds to the foldover frequency.
2503  *
2504  * Input Arguments:
2505  *   pSrc - pointer to the complex-valued input sequence represented
2506  *          using CCS format, of length (2^order) + 2; must be aligned on a
2507  *          32-byte boundary.
2508  *   pFFTSpec - pointer to the preallocated and initialized
2509  *              specification structure
2510  *
2511  * Output Arguments:
2512  *   pDst - pointer to the real-valued output sequence, of length
2513  *          2^order ; must be aligned on a 32-byte boundary.
2514  *
2515  * Return Value:
2516  *
2517  *    OMX_Sts_NoErr - no error
2518  *
2519  *    OMX_Sts_BadArgErr - bad arguments if one or more of the
2520  *      following is true:
2521  *    -    pSrc, pDst, or pFFTSpec is NULL
2522  *    -    pSrc or pDst is not aligned on a 32-byte boundary
2523  *    -    scaleFactor<0 or scaleFactor >32
2524  *
2525  */
2526 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs(
2527     const OMX_F32* pSrc,
2528     OMX_F32* pDst,
2529     const OMXFFTSpec_R_F32* pFFTSpec
2530 );
2531
2532 /*
2533  * This block sets things up appropriately for run-time or build-time selection
2534  * of NEON implementations.
2535  */
2536 #if defined(__arm__) || defined(__aarch64__)
2537 /*
2538  * Generic versions. Just like their *_Sfs counterparts, but automatically
2539  * detect whether NEON is available or not and choose the appropriate routine.
2540  */
2541 #if defined(DL_ARM_NEON_OPTIONAL)
2542 extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)(
2543     const OMX_F32* pSrc,
2544     OMX_F32* pDst,
2545     const OMXFFTSpec_R_F32* pFFTSpec
2546 );
2547 extern OMXResult (*omxSP_FFTInv_CCSToR_F32)(
2548     const OMX_F32* pSrc,
2549     OMX_F32* pDst,
2550     const OMXFFTSpec_R_F32* pFFTSpec);
2551 #elif defined(DL_ARM_NEON)
2552 /* Build-time NEON selection. */
2553 #define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs
2554 #define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs
2555 #else
2556 /* Build-time non-NEON selection. */
2557 #define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_CCSToR_F32_vfp
2558 #define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_vfp
2559 #endif  /* defined(DL_ARM_NEON_OPTIONAL) */
2560
2561 #if defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON)
2562 /* Non-NEON versions. */
2563 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp(
2564     const OMX_F32* pSrc,
2565     OMX_F32* pDst,
2566     const OMXFFTSpec_R_F32* pFFTSpec
2567 );
2568
2569 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp(
2570     const OMX_F32* pSrc,
2571     OMX_F32* pDst,
2572     const OMXFFTSpec_R_F32* pFFTSpec
2573 );
2574
2575 OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp (
2576     const OMX_FC32 *pSrc,
2577     OMX_FC32 *pDst,
2578     const OMXFFTSpec_C_FC32 *pFFTSpec
2579 );
2580
2581 OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp (
2582     const OMX_FC32 *pSrc,
2583     OMX_FC32 *pDst,
2584     const OMXFFTSpec_C_FC32 *pFFTSpec
2585 );
2586 #endif  /* defined(DL_ARM_NEON_OPTIONAL) || !defined(DL_ARM_NEON) */
2587
2588 #else
2589 /* Build-time non-ARM selection. */
2590 #define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs
2591 #define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs
2592 #endif  /* defined(__arm__) || defined(__aarch64__) */
2593
2594 #ifdef __cplusplus
2595 }
2596 #endif
2597
2598 #endif /** end of #define _OMXSP_H_ */
2599
2600 /** EOF */
2601