3 * Brief: OpenMAX DL v1.0.2 - Signal Processing library
5 * Copyright 2005-2008 The Khronos Group Inc. All Rights Reserved.
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.
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.
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
27 * Khronos and OpenMAX are trademarks of the Khronos Group Inc.
31 /* *****************************************************************************************/
36 #include "dl/api/omxtypes.h"
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;
53 * Function: omxSP_Copy_S16 (2.2.1.1.1)
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)
62 * pSrc - pointer to the source vector
63 * len - number of elements contained in the source and destination vectors
67 * pDst - pointer to the destination vector
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
78 OMXResult omxSP_Copy_S16 (
87 * Function: omxSP_DotProd_S16 (2.2.2.1.1)
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.
97 * pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
99 * pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
101 * len - length of the vectors in pSrc1 and pSrc2
107 * The dot product result Note: this function returns the actual result
108 * rather than the standard OMXError.
111 OMX_S32 omxSP_DotProd_S16 (
112 const OMX_S16 *pSrc1,
113 const OMX_S16 *pSrc2,
120 * Function: omxSP_DotProd_S16_Sfs (2.2.2.1.2)
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.
134 * pSrc1 - pointer to the first input vector; must be aligned on an 8-byte
136 * pSrc2 - pointer to the second input vector; must be aligned on an 8-byte
138 * len - length of the vectors in pSrc1 and pSrc2
139 * scaleFactor - integer scalefactor
145 * The dot product result Note: This function returns the actual result
146 * rather than the standard OMXError.
149 OMX_S32 omxSP_DotProd_S16_Sfs (
150 const OMX_S16 *pSrc1,
151 const OMX_S16 *pSrc2,
159 * Function: omxSP_BlockExp_S16 (2.2.2.2.2)
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.
170 * Note: These functions differ from other DL functions by not returning the
171 * standard OMXError but the actual result.
175 * pSrc - pointer to the input vector
176 * len - number of elements contained in the input and output
177 * vectors (0 < len < 65536)
185 * Maximum exponent that may be used in scaling
188 OMX_INT omxSP_BlockExp_S16 (
196 * Function: omxSP_BlockExp_S32 (2.2.2.2.2)
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.
207 * Note: These functions differ from other DL functions by not returning the
208 * standard OMXError but the actual result.
212 * pSrc - pointer to the input vector
213 * len - number of elements contained in the input and output
214 * vectors (0 < len < 65536)
222 * Maximum exponent that may be used in scaling
225 OMX_INT omxSP_BlockExp_S32 (
233 * Function: omxSP_FIR_Direct_S16 (2.2.3.1.1)
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.
249 * pSrc - pointer to the vector of input samples to which the
251 * sampLen - the number of samples contained in the input and output
253 * pTapsQ15 - pointer to the vector that contains the filter coefficients,
254 * represented in Q0.15 format (defined in section 1.6.5). Given
256 * -32768 = pTapsQ15(k) < 32768,
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.
272 * pDst - pointer to the vector of filtered output samples
276 * OMX_Sts_NoErr - no error
277 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
279 * - One or more of the following pointers is NULL:
288 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
291 OMXResult omxSP_FIR_Direct_S16 (
295 const OMX_S16 *pTapsQ15,
298 OMX_INT *pDelayLineIndex
304 * Function: omxSP_FIR_Direct_S16_I (2.2.3.1.1)
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.
319 * pSrcDst - pointer to the vector of input samples to which the
321 * sampLen - the number of samples contained in the input and output
323 * pTapsQ15 - pointer to the vector that contains the filter coefficients,
324 * represented in Q0.15 format (defined in section 1.6.5). Given
326 * -32768 = pTapsQ15(k) < 32768,
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.
342 * pSrcDst - pointer to the vector of filtered output samples
346 * OMX_Sts_NoErr - no error
347 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
349 * - One or more of the following pointers is NULL:
358 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
361 OMXResult omxSP_FIR_Direct_S16_I (
364 const OMX_S16 *pTapsQ15,
367 OMX_INT *pDelayLineIndex
373 * Function: omxSP_FIR_Direct_S16_Sfs (2.2.3.1.1)
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.
387 * pSrc - pointer to the vector of input samples to which the
389 * sampLen - the number of samples contained in the input and output
391 * pTapsQ15 - pointer to the vector that contains the filter coefficients,
392 * represented in Q0.15 format (defined in section 1.6.5). Given
394 * -32768 = pTapsQ15(k) < 32768,
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
411 * pDst - pointer to the vector of filtered output samples
415 * OMX_Sts_NoErr - no error
416 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
418 * - One or more of the following pointers is NULL:
428 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
431 OMXResult omxSP_FIR_Direct_S16_Sfs (
435 const OMX_S16 *pTapsQ15,
438 OMX_INT *pDelayLineIndex,
445 * Function: omxSP_FIR_Direct_S16_ISfs (2.2.3.1.1)
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.
459 * pSrcDst - pointer to the vector of input samples to which the
461 * sampLen - the number of samples contained in the input and output
463 * pTapsQ15 - pointer to the vector that contains the filter coefficients,
464 * represented in Q0.15 format (defined in section 1.6.5). Given
466 * -32768 = pTapsQ15(k) < 32768,
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
483 * pSrcDst - pointer to the vector of filtered output samples
487 * OMX_Sts_NoErr - no error
488 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
490 * - One or more of the following pointers is NULL:
500 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen).
503 OMXResult omxSP_FIR_Direct_S16_ISfs (
506 const OMX_S16 *pTapsQ15,
509 OMX_INT *pDelayLineIndex,
516 * Function: omxSP_FIROne_Direct_S16 (2.2.3.1.2)
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.
531 * val - the single input sample to which the filter is
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
536 * -32768 = pTapsQ15(k) < 32768,
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.
552 * pResult - pointer to the filtered output sample
556 * OMX_Sts_NoErr - no error
557 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
559 * - One or more of the following pointers is NULL:
565 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
568 OMXResult omxSP_FIROne_Direct_S16 (
571 const OMX_S16 *pTapsQ15,
574 OMX_INT *pDelayLineIndex
580 * Function: omxSP_FIROne_Direct_S16_I (2.2.3.1.2)
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.
595 * pValResult - pointer to the single input sample to which the filter is
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
600 * -32768 = pTapsQ15(k) < 32768,
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.
616 * pValResult - pointer to the filtered output sample
620 * OMX_Sts_NoErr - no error
621 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
623 * - One or more of the following pointers is NULL:
629 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
632 OMXResult omxSP_FIROne_Direct_S16_I (
634 const OMX_S16 *pTapsQ15,
637 OMX_INT *pDelayLineIndex
643 * Function: omxSP_FIROne_Direct_S16_Sfs (2.2.3.1.2)
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.
657 * val - the single input sample to which the filter is
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
662 * -32768 = pTapsQ15(k) < 32768,
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
679 * pResult - pointer to the filtered output sample
683 * OMX_Sts_NoErr - no error
684 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
686 * - One or more of the following pointers is NULL:
693 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
696 OMXResult omxSP_FIROne_Direct_S16_Sfs (
699 const OMX_S16 *pTapsQ15,
702 OMX_INT *pDelayLineIndex,
709 * Function: omxSP_FIROne_Direct_S16_ISfs (2.2.3.1.2)
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.
723 * pValResult - the pointer to a single input sample to which the filter is
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
728 * -32768 = pTapsQ15(k) < 32768,
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
745 * pValResult - pointer to the filtered output sample
749 * OMX_Sts_NoErr - no error
750 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
752 * - One or more of the following pointers is NULL:
759 * - *pDelayLineIndex < 0 or *pDelayLineIndex >= (2 * tapslen)
762 OMXResult omxSP_FIROne_Direct_S16_ISfs (
764 const OMX_S16 *pTapsQ15,
767 OMX_INT *pDelayLineIndex,
774 * Function: omxSP_IIR_Direct_S16 (2.2.3.2.1)
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.
788 * pSrc - pointer to the vector of input samples to which the
790 * len - the number of samples contained in both the input and output
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.
810 * pDst - pointer to the vector of filtered output samples
814 * OMX_Sts_NoErr - no error
815 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
817 * - one or more of the following pointers is NULL:
823 * - pTaps[order+1] < 0 (negative scaling)
827 OMXResult omxSP_IIR_Direct_S16 (
831 const OMX_S16 *pTaps,
839 * Function: omxSP_IIR_Direct_S16_I (2.2.3.2.1)
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.
853 * pSrcDst - pointer to the vector of input samples to which the
855 * len - the number of samples contained in both the input and output
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.
875 * pSrcDst - pointer to the vector of filtered output samples
879 * OMX_Sts_NoErr - no error
880 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
882 * - one or more of the following pointers is NULL:
887 * - pTaps[order+1] < 0 (negative scaling)
891 OMXResult omxSP_IIR_Direct_S16_I (
894 const OMX_S16 *pTaps,
902 * Function: omxSP_IIROne_Direct_S16 (2.2.3.2.2)
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.
916 * val - the single input sample to which the filter is
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.
936 * pResult - pointer to the filtered output sample
940 * OMX_Sts_NoErr - no error
941 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
943 * - one or more of the following pointers is NULL: pResult,
944 * pTaps, or pDelayLine.
946 * - pTaps[order+1] < 0 (negative scaling)
949 OMXResult omxSP_IIROne_Direct_S16 (
952 const OMX_S16 *pTaps,
960 * Function: omxSP_IIROne_Direct_S16_I (2.2.3.2.2)
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.
974 * pValResult - pointer to the single input sample to which the filter is
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.
994 * pValResult - pointer to the filtered output sample
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.
1004 * - pTaps[order+1] < 0 (negative scaling)
1007 OMXResult omxSP_IIROne_Direct_S16_I (
1008 OMX_S16 *pValResult,
1009 const OMX_S16 *pTaps,
1017 * Function: omxSP_IIR_BiQuadDirect_S16 (2.2.3.3.1)
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.
1031 * pSrc - pointer to the vector of input samples to which the
1033 * len - the number of samples contained in both the input and output
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:
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.
1049 * pDst - pointer to the vector of filtered output samples
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.
1060 * - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1063 OMXResult omxSP_IIR_BiQuadDirect_S16 (
1064 const OMX_S16 *pSrc,
1067 const OMX_S16 *pTaps,
1075 * Function: omxSP_IIR_BiQuadDirect_S16_I (2.2.3.3.1)
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.
1089 * pSrcDst - pointer to the vector of input samples to which the
1091 * len - the number of samples contained in both the input and output
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:
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.
1107 * pSrcDst - pointer to the vector of filtered output samples
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.
1118 * - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1121 OMXResult omxSP_IIR_BiQuadDirect_S16_I (
1124 const OMX_S16 *pTaps,
1132 * Function: omxSP_IIROne_BiQuadDirect_S16 (2.2.3.3.2)
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
1147 * val - the single input sample to which the filter is
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:
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.
1163 * pResult - pointer to the filtered output sample
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.
1173 * - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1176 OMXResult omxSP_IIROne_BiQuadDirect_S16 (
1179 const OMX_S16 *pTaps,
1187 * Function: omxSP_IIROne_BiQuadDirect_S16_I (2.2.3.3.2)
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
1202 * pValResult - pointer to the single input sample to which the filter is
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:
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.
1218 * pValResult - pointer to the filtered output sample
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.
1228 * - pTaps[3+n*6] < 0, for 0 <= n < numBiquad (negative scaling)
1231 OMXResult omxSP_IIROne_BiQuadDirect_S16_I (
1232 OMX_S16 *pValResult,
1233 const OMX_S16 *pTaps,
1241 * Function: omxSP_FilterMedian_S32 (2.2.3.4.1)
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.
1250 * pSrc - pointer to the input vector
1251 * len - number of elements contained in the input and output vectors (0 <
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)
1259 * pDst - pointer to the median-filtered output vector
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.
1268 * - maskSize < 1 or maskSize> 255
1269 * OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
1273 OMXResult omxSP_FilterMedian_S32 (
1274 const OMX_S32 *pSrc,
1283 * Function: omxSP_FilterMedian_S32_I (2.2.3.4.1)
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.
1292 * pSrcDst - pointer to the input vector
1293 * len - number of elements contained in the input and output vectors (0 <
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)
1301 * pSrcDst - pointer to the median-filtered output vector
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.
1310 * - maskSize < 1 or maskSize> 255
1311 * OMX_StsSP_EvenMedianMaskSizeErr - even mask size replaced by odd mask
1315 OMXResult omxSP_FilterMedian_S32_I (
1324 * Function: omxSP_FFTInit_C_SC16 (2.2.4.1.2)
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>.
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.
1337 * The space required for *pFFTSpec, in bytes, can be
1338 * determined using <FFTGetBufSize_C_SC16>.
1342 * order - base-2 logarithm of the desired block length;
1343 * valid in the range [0,12]
1347 * pFFTSpec - pointer to initialized specification structure
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
1356 * - order < 0 or order > 12
1359 OMXResult omxSP_FFTInit_C_SC16 (
1360 OMXFFTSpec_C_SC16 *pFFTSpec,
1367 * Function: omxSP_FFTInit_C_SC32 (2.2.4.1.2)
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>.
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.
1380 * The space required for *pFFTSpec, in bytes, can be
1381 * determined using <FFTGetBufSize_C_SC32>.
1385 * order - base-2 logarithm of the desired block length; valid in the range
1390 * pFFTSpec - pointer to initialized specification structure
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
1399 * - order < 0 or order > 12
1402 OMXResult omxSP_FFTInit_C_SC32 (
1403 OMXFFTSpec_C_SC32 *pFFTSpec,
1408 * Function: omxSP_FFTInit_C_FC32 (2.2.4.1.2)
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>.
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.
1421 * The space required for *pFFTSpec, in bytes, can be
1422 * determined using <FFTGetBufSize_C_FC32>.
1426 * order - base-2 logarithm of the desired block length; valid in the range
1431 * pFFTSpec - pointer to initialized specification structure
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
1440 * - order < 1 or order > 15
1443 OMXResult omxSP_FFTInit_C_FC32(
1444 OMXFFTSpec_C_FC32* pFFTSpec,
1451 * Function: omxSP_FFTInit_R_S16S32 (2.2.4.1.4)
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>.
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>.
1466 * order - base-2 logarithm of the desired block length; valid in the range
1471 * pFFTFwdSpec - pointer to the initialized specification structure
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
1480 * - order < 0 or order > 12
1483 OMXResult omxSP_FFTInit_R_S16S32(
1484 OMXFFTSpec_R_S16S32* pFFTFwdSpec,
1491 * Function: omxSP_FFTInit_R_S16
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>.
1499 * Memory for *pFFTFwdSpec must be allocated before calling these functions
1500 * and should be 8-byte aligned.
1502 * The number of bytes required for *pFFTFwdSpec can be
1503 * determined using <FFTGetBufSize_R_S16>.
1507 * order - base-2 logarithm of the desired block length; valid in the range
1512 * pFFTFwdSpec - pointer to the initialized specification structure
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
1521 * - order < 1 or order > 12
1524 OMXResult omxSP_FFTInit_R_S16 (
1525 OMXFFTSpec_R_S32*pFFTFwdSpec,
1530 * Function: omxSP_FFTInit_R_S32 (2.2.4.1.4)
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>.
1538 * Memory for *pFFTFwdSpec must be allocated before calling these functions
1539 * and should be 8-byte aligned.
1541 * The number of bytes required for *pFFTFwdSpec can be
1542 * determined using <FFTGetBufSize_R_S32>.
1546 * order - base-2 logarithm of the desired block length; valid in the range
1551 * pFFTFwdSpec - pointer to the initialized specification structure
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
1560 * - order < 0 or order > 12
1563 OMXResult omxSP_FFTInit_R_S32 (
1564 OMXFFTSpec_R_S32*pFFTFwdSpec,
1569 * Function: omxSP_FFTInit_R_F32
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>.
1577 * Memory for *pFFTFwdSpec must be allocated before calling these functions
1578 * and should be 8-byte aligned.
1580 * The number of bytes required for *pFFTFwdSpec can be
1581 * determined using <FFTGetBufSize_R_F32>.
1585 * order - base-2 logarithm of the desired block length; valid in the range
1590 * pFFTFwdSpec - pointer to the initialized specification structure
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
1599 * - order < 1 or order > 15
1602 OMXResult omxSP_FFTInit_R_F32(
1603 OMXFFTSpec_R_F32* pFFTFwdSpec,
1608 * Function: omxSP_FFTGetBufSize_C_SC16 (2.2.4.1.6)
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>.
1618 * order - base-2 logarithm of the desired block length; valid in the range
1623 * pSize - pointer to the number of bytes required for the specification
1628 * OMX_Sts_NoErr - no error
1629 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1630 * following is true:
1632 * - order < 0 or order > 12
1635 OMXResult omxSP_FFTGetBufSize_C_SC16 (
1643 * Function: omxSP_FFTGetBufSize_C_SC32 (2.2.4.1.6)
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>.
1653 * order - base-2 logarithm of the desired block length; valid in the range
1658 * pSize - pointer to the number of bytes required for the specification
1663 * OMX_Sts_NoErr - no error
1664 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1665 * following is true:
1667 * - order < 0 or order > 12
1670 OMXResult omxSP_FFTGetBufSize_C_SC32 (
1676 * Function: omxSP_FFTGetBufSize_C_FC32
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>.
1686 * order - base-2 logarithm of the desired block length; valid in the range
1691 * pSize - pointer to the number of bytes required for the specification
1696 * OMX_Sts_NoErr - no error
1697 * OMX_Sts_BadArgErr - bad arguments; returned if one or more of the
1698 * following is true:
1700 * - order < 1 or order > 15
1703 OMXResult omxSP_FFTGetBufSize_C_FC32(
1710 * Function: omxSP_FFTGetBufSize_R_S16S32 (2.2.4.1.8)
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>.
1720 * order - base-2 logarithm of the length; valid in the range [0,12]
1724 * pSize - pointer to the number of bytes required for the specification
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:
1733 * order < 0 or order > 12
1736 OMXResult omxSP_FFTGetBufSize_R_S16S32(
1743 * Function: omxSP_FFTGetBufSize_R_S16
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>.
1753 * order - base-2 logarithm of the length; valid in the range
1758 * pSize - pointer to the number of bytes required for the specification
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:
1767 * order < 1 or order > 12
1770 OMXResult omxSP_FFTGetBufSize_R_S16 (
1776 * Function: omxSP_FFTGetBufSize_R_S32 (2.2.4.1.8)
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>.
1786 * order - base-2 logarithm of the length; valid in the range [0,12]
1790 * pSize - pointer to the number of bytes required for the specification
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:
1799 * order < 0 or order > 12
1802 OMXResult omxSP_FFTGetBufSize_R_S32 (
1808 * Function: omxSP_FFTGetBufSize_R_F32
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>.
1818 * order - base-2 logarithm of the length; valid in the range [1,15]
1822 * pSize - pointer to the number of bytes required for the specification
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:
1831 * order < 1 or order > 15
1834 OMXResult omxSP_FFTGetBufSize_R_F32(
1842 * Function: omxSP_FFTFwd_CToC_SC16_Sfs (2.2.4.2.2)
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
1853 * X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
1854 * k = 0,1,2,..., N-1
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
1862 * scaleFactor - output scale factor; the range for is [0,16]
1865 * pDst - pointer to the complex-valued output vector, of length 2^order;
1866 * must be aligned on an 32-byte boundary.
1870 * OMX_Sts_NoErr - no error
1871 * OMX_Sts_BadArgErr - returned if one or more of the following conditions
1873 * - one or more of the following pointers is NULL: pSrc, pDst, or
1875 * - pSrc or pDst is not 32-byte aligned
1876 * - scaleFactor<0 or scaleFactor>16
1880 OMXResult omxSP_FFTFwd_CToC_SC16_Sfs (
1881 const OMX_SC16 *pSrc,
1883 const OMXFFTSpec_C_SC16 *pFFTSpec,
1887 OMXResult omxSP_FFTFwd_CToC_SC16_Sfs_neon (
1888 const OMX_SC16 *pSrc,
1890 const OMXFFTSpec_C_SC16 *pFFTSpec,
1895 * Function: omxSP_FFTFwd_CToC_SC32_Sfs (2.2.4.2.2)
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
1906 * X[k] = 2^(-scaleFactor) . SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
1907 * k = 0,1,2,..., N-1
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
1915 * scaleFactor - output scale factor; the range is [0,32]
1918 * pDst - pointer to the complex-valued output vector, of length 2^order; must be
1919 * aligned on an 32-byte boundary.
1923 * OMX_Sts_NoErr - no error
1924 * OMX_Sts_BadArgErr - returned if one or more of the following conditions
1926 * - one or more of the following pointers is NULL: pSrc, pDst, or
1928 * - pSrc or pDst is not 32-byte aligned
1929 * - scaleFactor<0 or scaleFactor >32
1932 OMXResult omxSP_FFTFwd_CToC_SC32_Sfs (
1933 const OMX_SC32 *pSrc,
1935 const OMXFFTSpec_C_SC32 *pFFTSpec,
1942 * Function: omxSP_FFTInv_CToC_SC16_Sfs (2.2.4.2.4)
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.:
1952 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
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
1961 * scaleFactor - scale factor of the output. Valid range is [0,16].
1965 * pDst - pointer to the complex-valued output signal, of length 2^order;
1966 * must be aligned on a 32-byte boundary.
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
1974 * - one or more of the following pointers is NULL: pSrc, pDst, or
1976 * - pSrc or pDst is not 32-byte aligned
1977 * - scaleFactor<0 or scaleFactor>16
1980 OMXResult omxSP_FFTInv_CToC_SC16_Sfs (
1981 const OMX_SC16 *pSrc,
1983 const OMXFFTSpec_C_SC16 *pFFTSpec,
1987 OMXResult omxSP_FFTInv_CToC_SC16_Sfs_neon (
1988 const OMX_SC16 *pSrc,
1990 const OMXFFTSpec_C_SC16 *pFFTSpec,
1998 * Function: omxSP_FFTInv_CToC_SC32_Sfs (2.2.4.2.4)
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.:
2008 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
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
2017 * scaleFactor - scale factor of the output. Valid range is [0,32].
2021 * pDst - pointer to the complex-valued output signal, of length 2^order;
2022 * must be aligned on a 32-byte boundary.
2026 * OMX_Sts_NoErr - no error
2027 * OMX_Sts_BadArgErr - returned if one or more of the following conditions
2029 * - one or more of the following pointers is NULL: pSrc, pDst, or
2031 * - pSrc or pDst is not 32-byte aligned
2032 * - scaleFactor<0 or scaleFactor>32
2035 OMXResult omxSP_FFTInv_CToC_SC32_Sfs (
2036 const OMX_SC32 *pSrc,
2038 const OMXFFTSpec_C_SC32 *pFFTSpec,
2045 * Function: omxSP_FFTFwd_RToCCS_S16S32_Sfs (2.2.4.4.2)
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.:
2055 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2059 * The conjugate-symmetric output sequence is represented using a CCS vector,
2060 * which is of length N+2, and is organized as follows:
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
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.
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
2075 * scaleFactor - output scale factor; valid range is [0, 32]
2078 * pDst - pointer to output sequence, represented using CCS format, of
2079 * length (2^order)+2; must be aligned on a 32-byte boundary.
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
2090 OMXResult omxSP_FFTFwd_RToCCS_S16S32_Sfs (
2091 const OMX_S16 *pSrc,
2093 const OMXFFTSpec_R_S16S32 *pFFTSpec,
2099 * Function: omxSP_FFTFwd_RToCCS_S16_Sfs
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.:
2109 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2113 * The conjugate-symmetric output sequence is represented using a CCS vector,
2114 * which is of length N+2, and is organized as follows:
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
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.
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
2129 * scaleFactor - output scale factor; valid range is [0, 16]
2132 * pDst - pointer to output sequence, represented using CCS format, of
2133 * length (2^order)+2; must be aligned on a 32-byte boundary.
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
2144 OMXResult omxSP_FFTFwd_RToCCS_S16_Sfs (
2145 const OMX_S16* pSrc,
2147 const OMXFFTSpec_R_S16* pFFTSpec,
2153 * Function: omxSP_FFTFwd_RToCCS_S32_Sfs (2.2.4.4.2)
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.:
2163 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2167 * The conjugate-symmetric output sequence is represented using a CCS vector,
2168 * which is of length N+2, and is organized as follows:
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
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.
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
2183 * scaleFactor - output scale factor; valid range is [0, 32]
2186 * pDst - pointer to output sequence, represented using CCS format, of
2187 * length (2^order)+2; must be aligned on a 32-byte boundary.
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
2198 OMXResult omxSP_FFTFwd_RToCCS_S32_Sfs (
2199 const OMX_S32 *pSrc,
2201 const OMXFFTSpec_R_S32 *pFFTSpec,
2206 * Function: omxSP_FFTFwd_CToC_FC32_Sfs (2.2.4.2.2)
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
2217 * X[k] = SUM[n=0...N-1]x[n].e^(-jnk.2.pi/N)
2218 * k = 0,1,2,..., N-1
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
2228 * pDst - pointer to the complex-valued output vector, of length 2^order;
2229 * must be aligned on an 32-byte boundary.
2233 * OMX_Sts_NoErr - no error
2234 * OMX_Sts_BadArgErr - returned if one or more of the following conditions
2236 * - one or more of the following pointers is NULL: pSrc, pDst, or
2238 * - pSrc or pDst is not 32-byte aligned
2239 * - scaleFactor<0 or scaleFactor >32
2242 OMXResult omxSP_FFTFwd_CToC_FC32_Sfs (
2243 const OMX_FC32 *pSrc,
2245 const OMXFFTSpec_C_FC32 *pFFTSpec
2251 OMXResult omxSP_FFTFwd_CToC_FC32_Sfs_vfp (
2252 const OMX_FC32 *pSrc,
2254 const OMXFFTSpec_C_FC32 *pFFTSpec
2259 * Function: omxSP_FFTFwd_RToCCS_F32_Sfs
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.:
2269 * x[n] = (2^(-scalefactor)/N) . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
2273 * The conjugate-symmetric output sequence is represented using a CCS vector,
2274 * which is of length N+2, and is organized as follows:
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
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.
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
2291 * pDst - pointer to output sequence, represented using CCS format, of
2292 * length (2^order)+2; must be aligned on a 32-byte boundary.
2296 * OMX_Sts_NoErr - no error
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
2303 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs(
2304 const OMX_F32* pSrc,
2306 const OMXFFTSpec_R_F32* pFFTSpec
2311 * Non-NEON version of omxSP_FFTFwd_RToCCS_F32_Sfs
2313 OMXResult omxSP_FFTFwd_RToCCS_F32_Sfs_vfp(
2314 const OMX_F32* pSrc,
2316 const OMXFFTSpec_R_F32* pFFTSpec
2320 * Just like omxSP_FFTFwd_RToCCS_F32_Sfs, but automatically detects
2321 * whether NEON is available or not and chooses the appropriate
2324 extern OMXResult (*omxSP_FFTFwd_RToCCS_F32)(
2325 const OMX_F32* pSrc,
2327 const OMXFFTSpec_R_F32* pFFTSpec
2330 #define omxSP_FFTFwd_RToCCS_F32 omxSP_FFTFwd_RToCCS_F32_Sfs
2334 * Function: omxSP_FFTInv_CCSToR_S32S16_Sfs (2.2.4.4.4)
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
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
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.
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
2356 * pFFTSpec - pointer to the preallocated and initialized specification
2358 * scaleFactor - output scalefactor; range is [0,16]
2361 * pDst - pointer to the real-valued output sequence, of length 2^order ; must be
2362 * aligned on a 32-byte boundary.
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
2373 OMXResult omxSP_FFTInv_CCSToR_S32S16_Sfs (
2374 const OMX_S32 *pSrc,
2376 const OMXFFTSpec_R_S16S32 *pFFTSpec,
2382 * Function: omxSP_FFTInv_CCSToR_S16_Sfs
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:
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
2395 * where R[n] and I[n], respectively, denote the real and imaginary components
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.
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
2405 * pFFTSpec - pointer to the preallocated and initialized specification
2407 * scaleFactor - output scalefactor; range is [0,16]
2410 * pDst - pointer to the real-valued output sequence, of length 2^order ; must
2411 * be aligned on a 32-byte boundary.
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
2422 OMXResult omxSP_FFTInv_CCSToR_S16_Sfs (
2423 const OMX_S16* pSrc,
2425 const OMXFFTSpec_R_S16* pFFTSpec,
2430 * Function: omxSP_FFTInv_CCSToR_S32_Sfs (2.2.4.4.4)
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
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
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.
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
2452 * pFFTSpec - pointer to the preallocated and initialized specification
2454 * scaleFactor - output scalefactor; range is [0,32]
2457 * pDst - pointer to the real-valued output sequence, of length 2^order ; must be
2458 * aligned on a 32-byte boundary.
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
2469 OMXResult omxSP_FFTInv_CCSToR_S32_Sfs (
2470 const OMX_S32 *pSrc,
2472 const OMXFFTSpec_R_S32 *pFFTSpec,
2477 * Function: omxSP_FFTInv_CToC_FC32_Sfs (2.2.4.2.4)
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.:
2487 * x[n] = SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
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
2499 * pDst - pointer to the complex-valued output signal, of length 2^order;
2500 * must be aligned on a 32-byte boundary.
2504 * OMX_Sts_NoErr - no error
2505 * OMX_Sts_BadArgErr - returned if one or more of the following conditions
2507 * - one or more of the following pointers is NULL: pSrc, pDst, or
2509 * - pSrc or pDst is not 32-byte aligned
2510 * - scaleFactor<0 or scaleFactor>32
2513 OMXResult omxSP_FFTInv_CToC_FC32_Sfs (
2514 const OMX_FC32 *pSrc,
2516 const OMXFFTSpec_C_FC32 *pFFTSpec
2522 OMXResult omxSP_FFTInv_CToC_FC32_Sfs_vfp (
2523 const OMX_FC32 *pSrc,
2525 const OMXFFTSpec_C_FC32 *pFFTSpec
2530 * Function: omxSP_FFTInv_CCSToR_F32_Sfs
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
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
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.
2549 * pSrc - pointer to the complex-valued input sequence represented
2550 * using CCS format, of length (2^order) + 2; must be aligned on a
2552 * pFFTSpec - pointer to the preallocated and initialized
2553 * specification structure
2556 * pDst - pointer to the real-valued output sequence, of length
2557 * 2^order ; must be aligned on a 32-byte boundary.
2561 * OMX_Sts_NoErr - no error
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
2570 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs(
2571 const OMX_F32* pSrc,
2573 const OMXFFTSpec_R_F32* pFFTSpec
2578 * Non-NEON version of omxSP_FFTInv_CCSToR_F32_Sfs
2580 OMXResult omxSP_FFTInv_CCSToR_F32_Sfs_vfp(
2581 const OMX_F32* pSrc,
2583 const OMXFFTSpec_R_F32* pFFTSpec
2587 * Just like omxSP_FFTInv_CCSToR_F32_Sfs, but automatically detects
2588 * whether NEON is available or not and chooses the appropriate
2591 extern OMXResult (*omxSP_FFTInv_CCSToR_F32)(
2592 const OMX_F32* pSrc,
2594 const OMXFFTSpec_R_F32* pFFTSpec);
2596 #define omxSP_FFTInv_CCSToR_F32 omxSP_FFTInv_CCSToR_F32_Sfs
2603 #endif /** end of #define _OMXSP_H_ */