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 #ifdef __arm__ 2248 /* 2249 * Non-NEON version 2250 */ 2251 OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp ( 2252 const OMX_FC32 *pSrc, 2253 OMX_FC32 *pDst, 2254 const OMXFFTSpec_C_FC32 *pFFTSpec 2255 ); 2256 #endif 2257 2258 /** 2259 * Function: omxSP_FFTFwd_RToCCS_F32_Sfs 2260 * 2261 * Description: 2262 * These functions compute an FFT for a real-valued signal of length 2263 * of 2^order, where 0 <= order <= 12. Transform length is determined 2264 * by the specification structure, which must be initialized prior to 2265 * calling the FFT function using the appropriate helper, i.e., 2266 * <FFTInit_R_F32>. The relationship between the input and output 2267 * sequences can be expressed in terms of the DFT, i.e.: 2268 * 2269 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) 2270 * n=0,1,2,...N-1 2271 * N=2^order. 2272 * 2273 * The conjugate-symmetric output sequence is represented using a CCS vector, 2274 * which is of length N+2, and is organized as follows: 2275 * 2276 * Index: 0 1 2 3 4 5 . . . N-2 N-1 N N+1 2277 * Component: R0 0 R1 I1 R2 I2 . . . R[N/2-1] I[N/2-1] R[N/2] 0 2278 * 2279 * where R[n] and I[n], respectively, denote the real and imaginary 2280 * components for FFT bin 'n'. Bins are numbered from 0 to N/2, where 2281 * N is the FFT length. Bin index 0 corresponds to the DC component, 2282 * and bin index N/2 corresponds to the foldover frequency. 2283 * 2284 * Input Arguments: 2285 * pSrc - pointer to the real-valued input sequence, of length 2^order; 2286 * must be aligned on a 32-byte boundary. 2287 * pFFTSpec - pointer to the preallocated and initialized specification 2288 * structure 2289 * 2290 * Output Arguments: 2291 * pDst - pointer to output sequence, represented using CCS format, of 2292 * length (2^order)+2; must be aligned on a 32-byte boundary. 2293 * 2294 * Return Value: 2295 * 2296 * OMX_Sts_NoErr - no error 2297 2298 * OMX_Sts_BadArgErr - bad arguments, if one or more of the 2299 * following is true: - one of the pointers pSrc, pDst, or pFFTSpec 2300 * is NULL - pSrc or pDst is not aligned on a 32-byte boundary 2301 * 2302 */ 2303 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs( 2304 const OMX_F32* pSrc, 2305 OMX_F32* pDst, 2306 const OMXFFTSpec_R_F32* pFFTSpec 2307 ); 2308 2309 #ifdef __arm__ 2310 /* 2311 * Non-NEON version of omxSP_FFTFwd_RToCCS_F32_Sfs 2312 */ 2313 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp( 2314 const OMX_F32* pSrc, 2315 OMX_F32* pDst, 2316 const OMXFFTSpec_R_F32* pFFTSpec 2317 ); 2318 2319 /* 2320 * Just like omxSP_FFTFwd_RToCCS_F32_Sfs, but automatically detects 2321 * whether NEON is available or not and chooses the appropriate 2322 * routine. 2323 */ 2324 extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)( 2325 const OMX_F32* pSrc, 2326 OMX_F32* pDst, 2327 const OMXFFTSpec_R_F32* pFFTSpec 2328 ); 2329 #else 2330 #define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs 2331 #endif 2332 2333 /** 2334 * Function: omxSP_FFTInv_CCSToR_S32S16_Sfs (2.2.4.4.4) 2335 * 2336 * Description: 2337 * These functions compute the inverse FFT for a conjugate-symmetric input 2338 * sequence. Transform length is determined by the specification structure, 2339 * which must be initialized prior to calling the FFT function using 2340 * <FFTInit_R_S16S32>. For a transform of length M, the input sequence is 2341 * represented using a packed CCS vector of length M+2, and is organized 2342 * as follows: 2343 * 2344 * Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 2345 * Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 2346 * 2347 * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n. 2348 * Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 2349 * corresponds to the DC component, and bin index M/2 corresponds to the 2350 * foldover frequency. 2351 * 2352 * Input Arguments: 2353 * pSrc - pointer to the complex-valued input sequence represented using 2354 * CCS format, of length (2^order) + 2; must be aligned on a 32-byte 2355 * boundary. 2356 * pFFTSpec - pointer to the preallocated and initialized specification 2357 * structure 2358 * scaleFactor - output scalefactor; range is [0,16] 2359 * 2360 * Output Arguments: 2361 * pDst - pointer to the real-valued output sequence, of length 2^order ; must be 2362 * aligned on a 32-byte boundary. 2363 * 2364 * Return Value: 2365 * 2366 * OMX_Sts_NoErr - no error 2367 * OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: 2368 * - pSrc, pDst, or pFFTSpec is NULL 2369 * - pSrc or pDst is not aligned on a 32-byte boundary 2370 * - scaleFactor<0 or scaleFactor >16 2371 * 2372 */ 2373 OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs ( 2374 const OMX_S32 *pSrc, 2375 OMX_S16 *pDst, 2376 const OMXFFTSpec_R_S16S32 *pFFTSpec, 2377 OMX_INT scaleFactor 2378 ); 2379 2380 2381 /** 2382 * Function: omxSP_FFTInv_CCSToR_S16_Sfs 2383 * 2384 * Description: 2385 * These functions compute the inverse FFT for a conjugate-symmetric input 2386 * sequence. Transform length is determined by the specification structure, 2387 * which must be initialized prior to calling the FFT function using 2388 * <FFTInit_R_S16>. For a transform of length M, the input 2389 * sequence is represented using a packed CCS vector of length 2390 * M+2, and is organized as follows: 2391 * 2392 * Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 2393 * Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 2394 * 2395 * where R[n] and I[n], respectively, denote the real and imaginary components 2396 * for FFT bin n. 2397 * Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 2398 * corresponds to the DC component, and bin index M/2 corresponds to the 2399 * foldover frequency. 2400 * 2401 * Input Arguments: 2402 * pSrc - pointer to the complex-valued input sequence represented using 2403 * CCS format, of length (2^order) + 2; must be aligned on a 32-byte 2404 * boundary. 2405 * pFFTSpec - pointer to the preallocated and initialized specification 2406 * structure 2407 * scaleFactor - output scalefactor; range is [0,16] 2408 * 2409 * Output Arguments: 2410 * pDst - pointer to the real-valued output sequence, of length 2^order ; must 2411 * be aligned on a 32-byte boundary. 2412 * 2413 * Return Value: 2414 * 2415 * OMX_Sts_NoErr - no error 2416 * OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: 2417 * - pSrc, pDst, or pFFTSpec is NULL 2418 * - pSrc or pDst is not aligned on a 32-byte boundary 2419 * - scaleFactor<0 or scaleFactor >16 2420 * 2421 */ 2422 OMXResult omxSP_FFTInv_CCSToR_S16_Sfs ( 2423 const OMX_S16* pSrc, 2424 OMX_S16* pDst, 2425 const OMXFFTSpec_R_S16* pFFTSpec, 2426 OMX_INT scaleFactor 2427 ); 2428 2429 /** 2430 * Function: omxSP_FFTInv_CCSToR_S32_Sfs (2.2.4.4.4) 2431 * 2432 * Description: 2433 * These functions compute the inverse FFT for a conjugate-symmetric input 2434 * sequence. Transform length is determined by the specification structure, 2435 * which must be initialized prior to calling the FFT function using 2436 * <FFTInit_R_S32>. For a transform of length M, the input sequence is 2437 * represented using a packed CCS vector of length M+2, and is organized 2438 * as follows: 2439 * 2440 * Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 2441 * Component R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 2442 * 2443 * where R[n] and I[n], respectively, denote the real and imaginary components for FFT bin n. 2444 * Bins are numbered from 0 to M/2, where M is the FFT length. Bin index 0 2445 * corresponds to the DC component, and bin index M/2 corresponds to the 2446 * foldover frequency. 2447 * 2448 * Input Arguments: 2449 * pSrc - pointer to the complex-valued input sequence represented using 2450 * CCS format, of length (2^order) + 2; must be aligned on a 32-byte 2451 * boundary. 2452 * pFFTSpec - pointer to the preallocated and initialized specification 2453 * structure 2454 * scaleFactor - output scalefactor; range is [0,32] 2455 * 2456 * Output Arguments: 2457 * pDst - pointer to the real-valued output sequence, of length 2^order ; must be 2458 * aligned on a 32-byte boundary. 2459 * 2460 * Return Value: 2461 * 2462 * OMX_Sts_NoErr - no error 2463 * OMX_Sts_BadArgErr - bad arguments if one or more of the following is true: 2464 * - pSrc, pDst, or pFFTSpec is NULL 2465 * - pSrc or pDst is not aligned on a 32-byte boundary 2466 * - scaleFactor<0 or scaleFactor >32 2467 * 2468 */ 2469 OMXResult omxSP_FFTInv_CCSToR_S32_Sfs ( 2470 const OMX_S32 *pSrc, 2471 OMX_S32 *pDst, 2472 const OMXFFTSpec_R_S32 *pFFTSpec, 2473 OMX_INT scaleFactor 2474 ); 2475 2476 /** 2477 * Function: omxSP_FFTInv_CToC_FC32_Sfs (2.2.4.2.4) 2478 * 2479 * Description: 2480 * These functions compute an inverse FFT for a complex signal of 2481 * length of 2^order, where 0 <= order <= 15. Transform length is 2482 * determined by the specification structure, which must be 2483 * initialized prior to calling the FFT function using the appropriate 2484 * helper, i.e., <FFTInit_C_FC32>. The relationship between the input 2485 * and output sequences can be expressed in terms of the IDFT, i.e.: 2486 * 2487 * x[n] = SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N) 2488 * n=0,1,2,...N-1 2489 * N=2^order. 2490 * 2491 * Input Arguments: 2492 * pSrc - pointer to the complex-valued input signal, of length 2^order ; 2493 * must be aligned on a 32-byte boundary. 2494 * pFFTSpec - pointer to the preallocated and initialized specification 2495 * structure 2496 * 2497 * Output Arguments: 2498 * order 2499 * pDst - pointer to the complex-valued output signal, of length 2^order; 2500 * must be aligned on a 32-byte boundary. 2501 * 2502 * Return Value: 2503 * 2504 * OMX_Sts_NoErr - no error 2505 * OMX_Sts_BadArgErr - returned if one or more of the following conditions 2506 * is true: 2507 * - one or more of the following pointers is NULL: pSrc, pDst, or 2508 * pFFTSpec. 2509 * - pSrc or pDst is not 32-byte aligned 2510 * - scaleFactor<0 or scaleFactor>32 2511 * 2512 */ 2513 OMXResult omxSP_FFTInv_CToC_FC32_Sfs ( 2514 const OMX_FC32 *pSrc, 2515 OMX_FC32 *pDst, 2516 const OMXFFTSpec_C_FC32 *pFFTSpec 2517 ); 2518 #ifdef __arm__ 2519 /* 2520 * Non-NEON version 2521 */ 2522 OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp ( 2523 const OMX_FC32 *pSrc, 2524 OMX_FC32 *pDst, 2525 const OMXFFTSpec_C_FC32 *pFFTSpec 2526 ); 2527 #endif 2528 2529 /** 2530 * Function: omxSP_FFTInv_CCSToR_F32_Sfs 2531 * 2532 * Description: 2533 * These functions compute the inverse FFT for a conjugate-symmetric input 2534 * sequence. Transform length is determined by the specification structure, 2535 * which must be initialized prior to calling the FFT function using 2536 * <FFTInit_R_F32>. For a transform of length M, the input sequence is 2537 * represented using a packed CCS vector of length M+2, and is organized 2538 * as follows: 2539 * 2540 * Index: 0 1 2 3 4 5 . . . M-2 M-1 M M+1 2541 * Comp: R[0] 0 R[1] I[1] R[2] I[2] . . . R[M/2-1] I[M/2-1] R[M/2] 0 2542 * 2543 * where R[n] and I[n], respectively, denote the real and imaginary 2544 * components for FFT bin n. Bins are numbered from 0 to M/2, where M 2545 * is the FFT length. Bin index 0 corresponds to the DC component, 2546 * and bin index M/2 corresponds to the foldover frequency. 2547 * 2548 * Input Arguments: 2549 * pSrc - pointer to the complex-valued input sequence represented 2550 * using CCS format, of length (2^order) + 2; must be aligned on a 2551 * 32-byte boundary. 2552 * pFFTSpec - pointer to the preallocated and initialized 2553 * specification structure 2554 * 2555 * Output Arguments: 2556 * pDst - pointer to the real-valued output sequence, of length 2557 * 2^order ; must be aligned on a 32-byte boundary. 2558 * 2559 * Return Value: 2560 * 2561 * OMX_Sts_NoErr - no error 2562 2563 * OMX_Sts_BadArgErr - bad arguments if one or more of the 2564 * following is true: 2565 * - pSrc, pDst, or pFFTSpec is NULL 2566 * - pSrc or pDst is not aligned on a 32-byte boundary 2567 * - scaleFactor<0 or scaleFactor >32 2568 * 2569 */ 2570 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs( 2571 const OMX_F32* pSrc, 2572 OMX_F32* pDst, 2573 const OMXFFTSpec_R_F32* pFFTSpec 2574 ); 2575 2576 #ifdef __arm__ 2577 /* 2578 * Non-NEON version of omxSP_FFTInv_CCSToR_F32_Sfs 2579 */ 2580 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp( 2581 const OMX_F32* pSrc, 2582 OMX_F32* pDst, 2583 const OMXFFTSpec_R_F32* pFFTSpec 2584 ); 2585 2586 /* 2587 * Just like omxSP_FFTInv_CCSToR_F32_Sfs, but automatically detects 2588 * whether NEON is available or not and chooses the appropriate 2589 * routine. 2590 */ 2591 extern OMXResult (*omxSP_FFTInv_CCSToR_F32)( 2592 const OMX_F32* pSrc, 2593 OMX_F32* pDst, 2594 const OMXFFTSpec_R_F32* pFFTSpec); 2595 #else 2596 #define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs 2597 #endif 2598 2599 #ifdef __cplusplus 2600 } 2601 #endif 2602 2603 #endif /** end of #define _OMXSP_H_ */ 2604 2605 /** EOF */ 2606 2607
