steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/intel_ipp_6.1.1.035/ia32/include/ipps.h

10845 lines
565 KiB
C
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
/* ////////////////////////////////// "ipps.h" /////////////////////////////////
//
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright(c) 1999-2009 Intel Corporation. All Rights Reserved.
//
// Intel(R) Integrated Performance Primitives
// Signal Processing (ippSP)
//
*/
#if !defined( __IPPS_H__ ) || defined( _OWN_BLDPCS )
#define __IPPS_H__
#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
#define _IPP_STDCALL_CDECL
#undef __stdcall
#endif
#if !defined( _OWN_BLDPCS )
typedef struct {
int left;
int right;
} IppsROI;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsGetLibVersion
// Purpose: get the library version
// Parameters:
// Returns: pointer to structure describing version of the ipps library
//
// Notes: don't free the pointer
*/
IPPAPI( const IppLibraryVersion*, ippsGetLibVersion, (void) )
/* /////////////////////////////////////////////////////////////////////////////
// Functions to allocate and free memory
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMalloc
// Purpose: 32-byte aligned memory allocation
// Parameter:
// len number of elements (according to their type)
// Returns: pointer to allocated memory
//
// Notes: the memory allocated by ippsMalloc has to be free by ippsFree
// function only.
*/
IPPAPI( Ipp8u*, ippsMalloc_8u, (int len) )
IPPAPI( Ipp16u*, ippsMalloc_16u, (int len) )
IPPAPI( Ipp32u*, ippsMalloc_32u, (int len) )
IPPAPI( Ipp8s*, ippsMalloc_8s, (int len) )
IPPAPI( Ipp16s*, ippsMalloc_16s, (int len) )
IPPAPI( Ipp32s*, ippsMalloc_32s, (int len) )
IPPAPI( Ipp64s*, ippsMalloc_64s, (int len) )
IPPAPI( Ipp32f*, ippsMalloc_32f, (int len) )
IPPAPI( Ipp64f*, ippsMalloc_64f, (int len) )
IPPAPI( Ipp8sc*, ippsMalloc_8sc, (int len) )
IPPAPI( Ipp16sc*, ippsMalloc_16sc, (int len) )
IPPAPI( Ipp32sc*, ippsMalloc_32sc, (int len) )
IPPAPI( Ipp64sc*, ippsMalloc_64sc, (int len) )
IPPAPI( Ipp32fc*, ippsMalloc_32fc, (int len) )
IPPAPI( Ipp64fc*, ippsMalloc_64fc, (int len) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFree
// Purpose: free memory allocated by the ippsMalloc functions
// Parameter:
// ptr pointer to the memory allocated by the ippsMalloc functions
//
// Notes: use the function to free memory allocated by ippsMalloc_*
*/
IPPAPI( void, ippsFree, (void* ptr) )
/* /////////////////////////////////////////////////////////////////////////////
// Vector Initialization functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCopy
// Purpose: copy data from source to destination vector
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsCopy_8u,( const Ipp8u* pSrc, Ipp8u* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_16s,( const Ipp16s* pSrc, Ipp16s* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_32f,( const Ipp32f* pSrc, Ipp32f* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_64f,( const Ipp64f* pSrc, Ipp64f* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_32s,( const Ipp32s* pSrc, Ipp32s* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_32sc,( const Ipp32sc* pSrc, Ipp32sc* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_64s,( const Ipp64s* pSrc, Ipp64s* pDst, int len ))
IPPAPI(IppStatus, ippsCopy_64sc,( const Ipp64sc* pSrc, Ipp64sc* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsPackBits_32u8u
// Purpose: Packing of bit's data from source to destination vector
// Parameters:
// pSrcBit pointer to the input vector with data bits
// pSrcBits pointer to the input vector that specifies number of data bits
// srcLen length of the pSrcBit and pSrcBits vectors, number of items
// pDst pointer to the output vector
// dstBitOffset offset in the first byte of the destination vector
// pDstLenBit pointer to the length of the output vector, number of bits
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsSizeErr dstBitOffset is less zero
//
// ippStsOverlongString Warning: pSrcBits[i] < 0, or pSrcBits[i] > 32.
//
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsPackBits_32u8u,( const Ipp32u* pSrcBit,
const int* pSrcBits,
int srcLen,
Ipp8u* pDst,
int dstBitOffset,
int* pDstLenBit ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCopy_1u
// Purpose: copy bit's data from source to destination vector
// Parameters:
// pSrc pointer to the input vector
// srcBitOffset offset in the first byte of the source vector
// pDst pointer to the output vector
// dstBitOffset offset in the first byte of the destination vector
// len length of the vectors, number of bits
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsCopy_1u,
( const Ipp8u* pSrc, int srcBitOffset, Ipp8u* pDst, int dstBitOffset, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMove
// Purpose: The ippsMove function copies "len" elements from src to dst.
// If some regions of the source area and the destination overlap,
// ippsMove ensures that the original source bytes in the overlapping
// region are copied before being overwritten.
//
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsMove_8u,
( const Ipp8u* pSrc, Ipp8u* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_16s,
( const Ipp16s* pSrc, Ipp16s* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_16sc,
( const Ipp16sc* pSrc, Ipp16sc* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_32f,
( const Ipp32f* pSrc, Ipp32f* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_64f,
( const Ipp64f* pSrc, Ipp64f* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_32s,
( const Ipp32s* pSrc, Ipp32s* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_32sc,
( const Ipp32sc* pSrc, Ipp32sc* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_64s,
( const Ipp64s* pSrc, Ipp64s* pDst, int len ))
IPPAPI ( IppStatus, ippsMove_64sc,
( const Ipp64sc* pSrc, Ipp64sc* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsZero
// Purpose: set elements of the vector to zero of corresponding type
// Parameters:
// pDst pointer to the destination vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsZero_8u,( Ipp8u* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_16s,( Ipp16s* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_16sc,( Ipp16sc* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_32f,( Ipp32f* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_32fc,( Ipp32fc* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_64f,( Ipp64f* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_64fc,( Ipp64fc* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_32s,( Ipp32s* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_32sc,( Ipp32sc* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_64s,( Ipp64s* pDst, int len ))
IPPAPI ( IppStatus, ippsZero_64sc,( Ipp64sc* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSet
// Purpose: set elements of the destination vector to the value
// Parameters:
// val value to set the elements of the vector
// pDst pointer to the destination vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsSet_8u,( Ipp8u val, Ipp8u* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_16s,( Ipp16s val, Ipp16s* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_16sc,( Ipp16sc val, Ipp16sc* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_32s,( Ipp32s val, Ipp32s* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_32sc,( Ipp32sc val, Ipp32sc* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_32f,( Ipp32f val, Ipp32f* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_32fc,( Ipp32fc val, Ipp32fc* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_64s,( Ipp64s val, Ipp64s* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_64sc,( Ipp64sc val, Ipp64sc* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_64f,( Ipp64f val, Ipp64f* pDst, int len ))
IPPAPI ( IppStatus, ippsSet_64fc,( Ipp64fc val, Ipp64fc* pDst, int len ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniform_Direct_16s, ippsRandUniform_Direct_32f, ippsRandUniform_Direct_64f
//
// Purpose: Makes pseudo-random samples with a uniform distribution and places them in
// the vector.
//
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr The pointer to vector is NULL
// ippStsBadSizeErr The length of the vector is less or equal zero
//
// Arguments:
// low The lower bounds of the uniform distributions range.
// high The upper bounds of the uniform distributions range.
// pSeed The pointer to the seed value used by the pseudo-random number
// generation algorithm.
// pSrcDst The pointer to vector
// len Vector's length
*/
IPPAPI(IppStatus, ippsRandUniform_Direct_16s, (Ipp16s* pDst, int len, Ipp16s low, Ipp16s high,
unsigned int* pSeed))
IPPAPI(IppStatus, ippsRandUniform_Direct_32f, (Ipp32f* pDst, int len, Ipp32f low, Ipp32f high,
unsigned int* pSeed))
IPPAPI(IppStatus, ippsRandUniform_Direct_64f, (Ipp64f* pDst, int len, Ipp64f low, Ipp64f high,
unsigned int* pSeed))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsRandGauss_Direct_16s, ippsRandGauss_Direct_32f, ippsRandGauss_Direct_64f
//
// Purpose: Makes pseudo-random samples with a Normal distribution distribution and places
// them in the vector.
//
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr The pointer to vector is NULL
// ippStsBadSizeErr The length of the vector is less or equal zero
//
// Arguments:
// mean The mean of the Normal distribution.
// stdev The standard deviation of the Normal distribution.
// pSeed The pointer to the seed value used by the pseudo-random number
// generation algorithm.
// pSrcDst The pointer to vector
// len Vector's length
*/
IPPAPI(IppStatus, ippsRandGauss_Direct_16s, (Ipp16s* pDst, int len, Ipp16s mean, Ipp16s stdev,
unsigned int* pSeed))
IPPAPI(IppStatus, ippsRandGauss_Direct_32f, (Ipp32f* pDst, int len, Ipp32f mean, Ipp32f stdev,
unsigned int* pSeed))
IPPAPI(IppStatus, ippsRandGauss_Direct_64f, (Ipp64f* pDst, int len, Ipp64f mean, Ipp64f stdev,
unsigned int* pSeed))
/* ///////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct RandUniState_8u;
struct RandUniState_16s;
struct RandUniState_32f;
typedef struct RandUniState_8u IppsRandUniState_8u;
typedef struct RandUniState_16s IppsRandUniState_16s;
typedef struct RandUniState_32f IppsRandUniState_32f;
struct RandGaussState_8u;
struct RandGaussState_16s;
struct RandGaussState_32f;
typedef struct RandGaussState_8u IppsRandGaussState_8u;
typedef struct RandGaussState_16s IppsRandGaussState_16s;
typedef struct RandGaussState_32f IppsRandGaussState_32f;
#endif
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniformInitAlloc_8u, ippsRandUniformInitAlloc_16s,
// ippsRandUniformInitAlloc_32f
// Purpose: Allocate and initialize parameters for the generator
// of noise with uniform distribution.
// Returns:
// Parameters:
// pRandUniState A pointer to the structure containing parameters for the
// generator of noise.
// low The lower bounds of the uniform distribution's range.
// high The upper bounds of the uniform distribution's range.
// seed The seed value used by the pseudo-random number generation
// algorithm.
//
// Returns:
// ippStsNullPtrErr pRandUniState==NULL
// ippMemAllocErr Can not allocate random uniform state
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRandUniformInitAlloc_8u, (IppsRandUniState_8u** pRandUniState,
Ipp8u low, Ipp8u high, unsigned int seed))
IPPAPI(IppStatus, ippsRandUniformInitAlloc_16s, (IppsRandUniState_16s** pRandUniState,
Ipp16s low, Ipp16s high, unsigned int seed))
IPPAPI(IppStatus, ippsRandUniformInitAlloc_32f, (IppsRandUniState_32f** pRandUniState,
Ipp32f low, Ipp32f high, unsigned int seed))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniform_8u, ippsRandUniform_16s,
// ippsRandUniform_32f
// Purpose: Makes pseudo-random samples with a uniform distribution
// and places them in the vector.
// Parameters:
// pDst The pointer to vector
// len Vector's length
// pRandUniState A pointer to the structure containing parameters for the
// generator of noise
// Returns:
// ippStsNullPtrErr pRandUniState==NULL
// ippStsContextMatchErr pState->idCtx != idCtxRandUni
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ippsRandUniform_8u, (Ipp8u* pDst, int len, IppsRandUniState_8u* pRandUniState))
IPPAPI(IppStatus, ippsRandUniform_16s, (Ipp16s* pDst, int len, IppsRandUniState_16s* pRandUniState))
IPPAPI(IppStatus, ippsRandUniform_32f, (Ipp32f* pDst, int len, IppsRandUniState_32f* pRandUniState))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniformFree_8u, ippsRandUniformFree_16s
// ippsRandUniformFree_32f
// Purpose: Close random uniform state
//
// Parameters:
// pRandUniState Pointer to the random uniform state
//
// Returns:
// ippStsNullPtrErr pState==NULL
// ippStsContextMatchErr pState->idCtx != idCtxRandUni
// ippStsNoErr, No errors
*/
IPPAPI (IppStatus, ippsRandUniformFree_8u, (IppsRandUniState_8u* pRandUniState))
IPPAPI (IppStatus, ippsRandUniformFree_16s, (IppsRandUniState_16s* pRandUniState))
IPPAPI (IppStatus, ippsRandUniformFree_32f, (IppsRandUniState_32f* pRandUniState))
/* //////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Name: ippsRandGaussInitAlloc_8u, ippsRandGaussInitAlloc_16s,
// ippsRandGaussInitAlloc_32f
// Purpose: Allocate and initialize parameters for the generator of noise.
// Returns:
// Parameters:
// pRandGaussState A pointer to the structure containing parameters for the
// generator of noise.
// mean The mean of the normal distribution.
// stdDev The standard deviation of the normal distribution.
// seed The seed value used by the pseudo-random number
//
// Returns:
// ippStsNullPtrErr pRandGaussState==NULL
// ippMemAllocErr Can not allocate normal random state
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRandGaussInitAlloc_8u, (IppsRandGaussState_8u** pRandGaussState,
Ipp8u mean, Ipp8u stdDev, unsigned int seed))
IPPAPI(IppStatus, ippsRandGaussInitAlloc_16s, (IppsRandGaussState_16s** pRandGaussState,
Ipp16s mean, Ipp16s stdDev, unsigned int seed))
IPPAPI(IppStatus, ippsRandGaussInitAlloc_32f, (IppsRandGaussState_32f** pRandGaussState,
Ipp32f mean, Ipp32f stdDev, unsigned int seed))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsRandGauss_8u, ippsRandGauss_16s,
// ippsRandGauss_32f
// Purpose: Makes pseudo-random samples with a normal distribution
// and places them in the vector.
// Parameters:
// pDst The pointer to vector
// len Vector's length
// pRandUniState A pointer to the structure containing parameters
// for the generator of noise
// ippStsContextMatchErr pState->idCtx != idCtxRandGauss
// Returns:
// ippStsNullPtrErr pRandGaussState==NULL
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ippsRandGauss_8u, (Ipp8u* pDst, int len, IppsRandGaussState_8u* pRandGaussState))
IPPAPI(IppStatus, ippsRandGauss_16s, (Ipp16s* pDst, int len, IppsRandGaussState_16s* pRandGaussState))
IPPAPI(IppStatus, ippsRandGauss_32f, (Ipp32f* pDst, int len, IppsRandGaussState_32f* pRandGaussState))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsRandGaussFree_8u, ippsRandGaussFree_16s,
// ippsRandGaussFree_32f
// Purpose: Close random normal state
//
// Parameters:
// pRandUniState Pointer to the random normal state
//
// Returns:
// ippStsNullPtrErr pState==NULL
// ippStsContextMatchErr pState->idCtx != idCtxRandGauss
// ippStsNoErr, No errors
*/
IPPAPI (IppStatus, ippsRandGaussFree_8u, (IppsRandGaussState_8u* pRandGaussState))
IPPAPI (IppStatus, ippsRandGaussFree_16s, (IppsRandGaussState_16s* pRandGaussState))
IPPAPI (IppStatus, ippsRandGaussFree_32f, (IppsRandGaussState_32f* pRandGaussState))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsRandGaussGetSize_16s
//
// Purpose: Gaussian sequence generator state variable size -
// computes the size,in bytes,
// of the state variable structure ippsRandGaussState_16s.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pRandGaussStateSize==NULL
// Arguments:
// pRandGaussStateSize pointer to the computed values of the size
// of the structure ippsRandGaussState_16s.
*/
IPPAPI(IppStatus, ippsRandGaussGetSize_16s, (int * pRandGaussStateSize))
/* //////////////////////////////////////////////////////////////////////////////////
// Name: ippsRandGaussInit_16s
// Purpose: Initializes the Gaussian sequence generator state structure with
// given parameters (mean, variance, seed).
// Parameters:
// pRandGaussState A pointer to the structure containing parameters for the
// generator of noise.
// mean Mean of the normal distribution.
// stdDev Standard deviation of the normal distribution.
// seed Seed value used by the pseudo-random number generator
//
// Returns:
// ippStsNullPtrErr pRandGaussState==NULL
// ippMemAllocErr Can not allocate normal random state
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRandGaussInit_16s, (IppsRandGaussState_16s* pRandGaussState,
Ipp16s mean, Ipp16s stdDev, unsigned int seed))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniformGetSize_16s
//
// Purpose: Uniform sequence generator state variable size -
// computes the size,in bytes,
// of the state variable structure ippsRandIniState_16s.
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pRandUniformStateSize==NULL
// Arguments:
// pRandGaussStateSize pointer to the computed value of the size
// of the structure ippsRandUniState_16s.
*/
IPPAPI(IppStatus, ippsRandUniformGetSize_16s, (int * pRandUniformStateSize))
/* //////////////////////////////////////////////////////////////////////////////////
// Name: ippsRandUniformInit_16s
// Purpose: Initializes the uniform sequence generator state structure with
// given parameters (boundaries, seed)
// Parameters:
// pRandUniState Pointer to the structure containing parameters for the
// generator of noise.
// low Lower bound of the uniform distribution's range.
// high Upper bounds of the uniform distribution's range.
// seed Seed value used by the pseudo-random number generation
// algorithm.
//
*/
IPPAPI(IppStatus, ippsRandUniformInit_16s, (IppsRandUniState_16s* pRandUniState,
Ipp16s low, Ipp16s high, unsigned int seed))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsVectorJaehne
// Purpose: creates Jaehne vector
//
// Parameters:
// pDst the pointer to the destination vector
// len length of the vector
// magn magnitude of the signal
//
// Return:
// ippStsNoErr indicates no error
// ippStsNullPtrErr indicates an error when the pDst pointer is NULL
// ippStsBadSizeErr indicates an error when len is less or equal zero
// ippStsJaehneErr indicates an error when magnitude value is negative
//
// Notes: pDst[n] = magn*sin(0.5*pi*n^2/len), n=0,1,2,..len-1.
//
*/
IPPAPI (IppStatus, ippsVectorJaehne_8u, (Ipp8u* pDst, int len, Ipp8u magn))
IPPAPI (IppStatus, ippsVectorJaehne_8s, (Ipp8s* pDst, int len, Ipp8s magn))
IPPAPI (IppStatus, ippsVectorJaehne_16u, (Ipp16u* pDst, int len, Ipp16u magn))
IPPAPI (IppStatus, ippsVectorJaehne_16s, (Ipp16s* pDst, int len, Ipp16s magn))
IPPAPI (IppStatus, ippsVectorJaehne_32u, (Ipp32u* pDst, int len, Ipp32u magn))
IPPAPI (IppStatus, ippsVectorJaehne_32s, (Ipp32s* pDst, int len, Ipp32s magn))
IPPAPI (IppStatus, ippsVectorJaehne_32f, (Ipp32f* pDst, int len, Ipp32f magn))
IPPAPI (IppStatus, ippsVectorJaehne_64f, (Ipp64f* pDst, int len, Ipp64f magn))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsTone_Direct
// Purpose: generates a tone
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of vector is less or equal zero
// ippStsToneMagnErr The magn value is less than or equal to zero
// ippStsToneFreqErr The rFreq value is less than 0 or greater than or equal to 0.5
// for real tone and 1.0 for complex tone
// ippStsTonePhaseErr The phase value is less 0 or greater or equal 2*PI
// Parameters:
// magn Magnitude of the tone; that is, the maximum value
// attained by the wave
// rFreq Frequency of the tone relative to the sampling
// frequency. It must be in range [0.0, 0.5) for real, and
// [0.0, 1.0) for complex tone
// pPhase Phase of the tone relative to a cosinewave. It must
// be in range [0.0, 2*PI).
// pDst Pointer to the destination vector.
// len Length of the vector
// hint Suggests using specific code
// Notes:
// for real: pDst[i] = magn * cos(IPP_2PI * rfreq * i + phase);
// for cplx: pDst[i].re = magn * cos(IPP_2PI * rfreq * i + phase);
// pDst[i].im = magn * sin(IPP_2PI * rfreq * i + phase);
*/
IPPAPI(IppStatus, ippsTone_Direct_32f, (Ipp32f* pDst, int len, float magn,
float rFreq, float* pPhase, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsTone_Direct_32fc, (Ipp32fc* pDst, int len, float magn,
float rFreq, float* pPhase, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsTone_Direct_64f, (Ipp64f* pDst, int len, double magn,
double rFreq, double* pPhase, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsTone_Direct_64fc, (Ipp64fc* pDst, int len, double magn,
double rFreq, double* pPhase, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsTone_Direct_16s, (Ipp16s* pDst, int len, Ipp16s magn,
float rFreq, float* pPhase, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsTone_Direct_16sc, (Ipp16sc* pDst, int len, Ipp16s magn,
float rFreq, float* pPhase, IppHintAlgorithm hint))
#if !defined ( _OWN_BLDPCS )
struct ToneState_16s;
typedef struct ToneState_16s IppToneState_16s;
#endif
/*
// Name: ippsToneInitAllocQ15_16s
// Purpose: Allocates memory for the structure IppToneState_16s,
// initializes it with a set of cosinwave parameters (magnitude,
// frequency, phase).
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Double pointer to pToneState is NULL
// ippStsToneMagnErr The magn value is less than or equal to zero
// ippStsToneFreqErr The freqQ15 value is less than 0 or greater than 16383
// ippStsTonePhaseErr The phaseQ15 value is less than 0 or greater than 205886
// Parameters:
// **pToneState Double pointer to the structure IppToneState_16s.
// magn Magnitude of the tone; that is, the maximum value
// attained by the wave.
// rFreqQ15 Frequency of the tone relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 Phase of the tone relative to a cosinewave. It must
// be between 0 and 205886.
// Notes:
*/
IPPAPI(IppStatus, ippsToneInitAllocQ15_16s, (IppToneState_16s** pToneState,
Ipp16s magn, Ipp16s rFreqQ15, Ipp32s phaseQ15))
/*
// Name: ippsToneFree_16s
// Purpose: Frees memory, which was allocated
// for the structure IppToneState_16s.
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Pointer to pToneState is NULL
// Parameters:
// *pToneState Pointer to the structure IppToneState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsToneFree, (IppToneState_16s* pToneState))
/*
// Name: ippsToneGetStateSizeQ15_16s
// Purpose: Computes the size, in bytes, of the structure IppToneState_16s
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Pointer to pToneState size is NULL
// Parameters:
// *pToneStateSize Pointer to the computed value of the size
// of the structure IppToneState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsToneGetStateSizeQ15_16s, (int* pToneStateSize))
/*
// Name: ippsToneInitQ15_16s
// Purpose: initializes the structure IppToneState_16s with
// given set of cosinewave parameters (magnitude,
// frequency, phase)
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Pointer to pToneState is NULL
// ippStsToneMagnErr The magn value is less than or equal to zero
// ippStsToneFreqErr The rFreqQ15 value is less than 0 or greater 16383
// ippStsTonePhaseErr The phaseQ15 value is less than 0 or greater 205886
// Parameters:
// *pToneState Pointer to the structure IppToneState_16s.
// magn Magnitude of the tone; that is, the maximum value
// attained by the wave.
// rFreqQ15 Frequency of the tone relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 Phase of the tone relative to a cosinewave. It must
// be between 0 and 205886.
// Notes:
*/
IPPAPI(IppStatus, ippsToneInitQ15_16s, (IppToneState_16s* pToneState, Ipp16s magn,
Ipp16s rFreqQ15, Ipp32s phaseQ15))
/*
// Name: ippsToneQ15_16s
// Purpose: generates a tone
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr One of the specified pointers is NULL
// ippStsSizeErr len is less than or equal to 0
// Parameters:
// pDst Pointer to the destination vector.
// len Length of the vector
// *pToneState Pointer to the structure IppToneState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsToneQ15_16s, (Ipp16s* pDst, int len, IppToneState_16s* pToneState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsTriangle_Direct
// Purpose: generates a Triangle
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of vector is less or equal zero
// ippStsTrnglMagnErr The magn value is less or equal to zero
// ippStsTrnglFreqErr The rfreq value is less 0 or greater or equal 0.5
// ippStsTrnglPhaseErr The phase value is less 0 or greater or equal 2*PI
// ippStsTrnglAsymErr The asym value is less -PI or greater or equal PI
// Parameters:
// magn Magnitude of the Triangle; that is, the maximum value
// attained by the wave
// rFreq Frequency of the Triangle relative to the sampling
// frequency. It must be in range [0.0, 0.5)
// pPhase POinter to the phase of the Triangle relative to acosinewave. It must
// be in range [0.0, 2*PI)
// asym Asymmetry of a triangle. It must be in range [-PI,PI).
// pDst Pointer to destination vector.
// len Length of the vector
*/
IPPAPI(IppStatus, ippsTriangle_Direct_64f, (Ipp64f* pDst, int len, double magn,
double rFreq, double asym, double* pPhase))
IPPAPI(IppStatus, ippsTriangle_Direct_64fc, (Ipp64fc* pDst, int len, double magn,
double rFreq, double asym, double* pPhase))
IPPAPI(IppStatus, ippsTriangle_Direct_32f, (Ipp32f* pDst, int len, float magn,
float rFreq, float asym, float* pPhase))
IPPAPI(IppStatus, ippsTriangle_Direct_32fc, (Ipp32fc* pDst, int len, float magn,
float rFreq, float asym, float* pPhase))
IPPAPI(IppStatus, ippsTriangle_Direct_16s, (Ipp16s* pDst, int len, Ipp16s magn,
float rFreq, float asym, float* pPhase))
IPPAPI(IppStatus, ippsTriangle_Direct_16sc, (Ipp16sc* pDst, int len, Ipp16s magn,
float rFreq, float asym, float* pPhase))
#if !defined ( _OWN_BLDPCS )
/* IPP Context triangle identification */
struct TriangleState_16s;
typedef struct TriangleState_16s IppTriangleState_16s;
#endif
/*
// Name: ippsTriangleInitAllocQ15_16s
// Purpose: Allocates memory for the structure IppTriangleState_16s,
// initializes it with a set of wave parameters (magnitude,
// frequency, phase, asymmetry).
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Double pointer to pTriangleState is NULL
// ippStsTriangleMagnErr The magn value is less than or equal to zero
// ippStsTriangleFreqErr The freqQ15 value is less than 0 or greater than 16383
// ippStsTriangleAsymErr The phaseQ15 value is less than 0 or greater than 205886
// ippStsTrianglePhaseErr The asymQ15 value is less than -102943 or greater than 102943
// Parameters:
// **pTriangleState Double pointer to the structure IppTriangleState_16s.
// magn Magnitude of the Triangle; that is, the maximum value
// attained by the wave.
// rFreqQ15 Frequency of the Triangle relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 Phase of the Triangle relative to a wave. It must
// be between 0 and 205886.
// asymQ15 Asymmetry of the Triangle relative to a wave. It must
// be between -102943 and 102943.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleInitAllocQ15_16s, (IppTriangleState_16s** pTriangleState,
Ipp16s magn, Ipp16s rFreqQ15, Ipp32s phaseQ15, Ipp32s asymQ15))
/*
// Name: ippsTriangleFree_16s
// Purpose: Frees memory, which was allocated
// for the structure IppTriangleState_16s.
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Pointer to pTriangleState is NULL
// Parameters:
// *pTriangleState Pointer to the structure IppTriangleState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleFree, (IppTriangleState_16s* pTriangleState))
/*
// Name: ippsTriangleGetStateSizeQ15_16s
// Purpose: Computes the size, in bytes, of the structure IppTriangleState_16s
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr Pointer to pTriangleState size is NULL
// Parameters:
// *pTriangleStateSize Pointer to the computed value of the size
// of the structure IppTriangleState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleGetStateSizeQ15_16s, (int* pTriangleStateSize))
/*
// Name: ippsTriangleInitQ15_16s
// Purpose: Initializes the structure IppTriangleState_16s
// with a given set of cosinewave parameters (magnitude,
// frequency, phase)
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr The pointer to pTriangleState is NULL
// ippStsTrngleMagnErr The magn value is less than or equal to zero
// ippStsTrngleFreqErr The freqQ15 value is less than 0 or greater than 16383
// ippStsTrnglePhaseErr The phaseQ15 value is less than 0 or greater than 205886
// ippStsTrngleAsymErr The asymQ15 value is less than -102943 or greater than 102943
// Parameters:
// *pTriangleState Pointer to the structure IppTriangleState_16s.
// magn Magnitude of the Triangle; that is, the maximum value
// attained by the wave.
// rFreqQ15 Frequency of the Triangle relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 Phase of the Triangle relative to a wave. It must
// be between 0 and 205886.
// asymQ15 Asymmetry of the Triangle relative to a wave. It must
// be between -102943 and 102943.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleInitQ15_16s, (IppTriangleState_16s* pTriangleState,
Ipp16s magn, Ipp16s rFreqQ15, Ipp32s phaseQ15, Ipp32s asymQ15))
/*
// Name: ippsTriangleQ15_16s
// Purpose: generates a Triangle
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// Parameters:
// pDst The pointer to destination vector.
// len The length of vector
// *pTriangleState Pointer to the structure IppTriangleState_16s.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleQ15_16s, (Ipp16s* pDst, int len, IppTriangleState_16s* pTriangleState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsToneQ15_Direct_16s
// Purpose: generates a tone
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr The pointer to the destination vector is NULL
// ippStsSizeErr The length of the vector is less than or equal to zero
// ippStsToneMagnErr The magn value is less than or equal to zero
// ippStsToneFreqErr The rFreqQ15 value is less than 0 or greater than 16383
// ippStsTonePhaseErr The phaseQ15 value is less than 0 or greater than 205886
// Parameters:
// pDst Pointer to the destination vector.
// len Length of the vector
// magn Magnitude of the tone; that is, the maximum value
// attained by the wave.It must be between 0 and 32767
// rFreqQ15 Frequency of the tone relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 Phase of the tone relative to a cosinewave. It must
// be between 0 and 205886.
*/
IPPAPI(IppStatus, ippsToneQ15_Direct_16s, (Ipp16s* pDst, int len,
Ipp16s magn, Ipp16s rFreqQ15, Ipp32s phaseQ15))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsTriangleQ15_Direct_16s
// Purpose: generates a Triangle
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr The pointer to the destination vector is NULL
// ippStsSizeErr The length of the vector is less than or equal to zero
// ippStsTriangleMagnErr The magn value is less than or equal to zero
// ippStsTriangleFreqErr The rFfreqQ15 value is less than 0 or greater than 16383
// ippStsTriangleAsymErr The asymQ15 value is less than 0 or greater than 205886
// ippStsTrianglePhaseErr The phaseQ15 value is less than -102943 or greater than 102943
// Parameters:
// pDst Pointer to the destination vector.
// len Length of the vector
// mag Magnitude of the Triangle; that is, the maximum value
// attained by the wave. It must be between 0 and 32767.
// rFreqQ15 Frequency of the Triangle relative to the sampling
// frequency. It must be between 0 and 16383
// phaseQ15 The phase of the Triangle relative to a wave. It must
// be between 0 and 205886.
// asymQ15 The asymmetry of the Triangle relative to a wave. It must
// be between -102943 and 102943.
// Notes:
*/
IPPAPI(IppStatus, ippsTriangleQ15_Direct_16s, ( Ipp16s* pDst, int len,
Ipp16s magn, Ipp16s rFreqQ15,
Ipp32s phaseQ15, Ipp32s asymQ15))
/* /////////////////////////////////////////////////////////////////////////
// Name: ippsVectorRamp_8u, ippsVectorRamp_8s,
// ippsVectorRamp_16u, ippsVectorRamp_16s,
// ippsVectorRamp_32u, ippsVectorRamp_32s,
// ippsVectorRamp_32f, ippsVectorRamp_64f
// Purpose: Creates ramp vector
//
// Parameters:
// pDst A pointer to the destination vector
// len Vector's length
// offset Offset value
// slope Slope coefficient
//
// Return:
// ippStsNoErr No error
// ippStsNullPtrErr pDst pointer is NULL
// ippStsBadSizeErr Vector's length is less or equal zero
// ippStsNoErr No error
//
// Notes: Dst[n] = offset + slope * n
//
*/
IPPAPI (IppStatus, ippsVectorRamp_8u, (Ipp8u* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_8s, (Ipp8s* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_16u, (Ipp16u* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_16s, (Ipp16s* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_32u, (Ipp32u* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_32s, (Ipp32s* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_32f, (Ipp32f* pDst, int len, float offset, float slope))
IPPAPI (IppStatus, ippsVectorRamp_64f, (Ipp64f* pDst, int len, float offset, float slope))
/* /////////////////////////////////////////////////////////////////////////////
// Convert functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsReal
// Purpose: form vector with real part of the input complex vector
// Parameters:
// pSrc pointer to the input complex vector
// pDstRe pointer to the output vector to store the real part
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsReal_64fc,(const Ipp64fc* pSrc, Ipp64f* pDstRe, int len))
IPPAPI(IppStatus, ippsReal_32fc,(const Ipp32fc* pSrc, Ipp32f* pDstRe, int len))
IPPAPI(IppStatus, ippsReal_16sc,(const Ipp16sc* pSrc, Ipp16s* pDstRe, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsImag
// Purpose: form vector with imaginary part of the input complex vector
// Parameters:
// pSrc pointer to the input complex vector
// pDstRe pointer to the output vector to store the real part
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsImag_64fc,(const Ipp64fc* pSrc, Ipp64f* pDstIm, int len))
IPPAPI(IppStatus, ippsImag_32fc,(const Ipp32fc* pSrc, Ipp32f* pDstIm, int len))
IPPAPI(IppStatus, ippsImag_16sc,(const Ipp16sc* pSrc, Ipp16s* pDstIm, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCplxToReal
// Purpose: form the real and imaginary parts of the input complex vector
// Parameters:
// pSrc pointer to the input complex vector
// pDstRe pointer to output vector to store the real part
// pDstIm pointer to output vector to store the imaginary part
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsCplxToReal_64fc,( const Ipp64fc* pSrc, Ipp64f* pDstRe,
Ipp64f* pDstIm, int len ))
IPPAPI(IppStatus, ippsCplxToReal_32fc,( const Ipp32fc* pSrc, Ipp32f* pDstRe,
Ipp32f* pDstIm, int len ))
IPPAPI(IppStatus, ippsCplxToReal_16sc,( const Ipp16sc* pSrc, Ipp16s* pDstRe,
Ipp16s* pDstIm, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRealToCplx
// Purpose: form complex vector from the real and imaginary components
// Parameters:
// pSrcRe pointer to the input vector with real part, may be NULL
// pSrcIm pointer to the input vector with imaginary part, may be NULL
// pDst pointer to the output complex vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the destination data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
//
// Notes: one of the two input pointers may be NULL. In this case
// the corresponding values of the output complex elements is 0
*/
IPPAPI(IppStatus, ippsRealToCplx_64f,( const Ipp64f* pSrcRe,
const Ipp64f* pSrcIm, Ipp64fc* pDst, int len ))
IPPAPI(IppStatus, ippsRealToCplx_32f,( const Ipp32f* pSrcRe,
const Ipp32f* pSrcIm, Ipp32fc* pDst, int len ))
IPPAPI(IppStatus, ippsRealToCplx_16s,( const Ipp16s* pSrcRe,
const Ipp16s* pSrcIm, Ipp16sc* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsConj, ippsConjFlip
// Purpose: complex conjugate data vector
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Notes:
// the ConjFlip version conjugates and stores result in reverse order
*/
IPPAPI ( IppStatus, ippsConj_64fc_I, ( Ipp64fc* pSrcDst, int len ))
IPPAPI ( IppStatus, ippsConj_32fc_I, ( Ipp32fc* pSrcDst, int len ))
IPPAPI ( IppStatus, ippsConj_16sc_I, ( Ipp16sc* pSrcDst, int len ))
IPPAPI ( IppStatus, ippsConj_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst, int len ))
IPPAPI ( IppStatus, ippsConj_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst, int len ))
IPPAPI ( IppStatus, ippsConj_16sc,
( const Ipp16sc* pSrc, Ipp16sc* pDst, int len ))
IPPAPI ( IppStatus, ippsConjFlip_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst, int len ))
IPPAPI ( IppStatus, ippsConjFlip_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst, int len ))
IPPAPI ( IppStatus, ippsConjFlip_16sc,
( const Ipp16sc* pSrc, Ipp16sc* pDst, int len ))
IPPAPI ( IppStatus, ippsConjCcs_64fc_I,
( Ipp64fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjCcs_32fc_I,
( Ipp32fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjCcs_16sc_I,
( Ipp16sc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjCcs_64fc,
( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjCcs_32fc,
( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjCcs_16sc,
( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_64fc_I,
( Ipp64fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_32fc_I,
( Ipp32fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_16sc_I,
( Ipp16sc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_64fc,
( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_32fc,
( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPack_16sc,
( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_64fc_I,
( Ipp64fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_32fc_I,
( Ipp32fc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_16sc_I,
( Ipp16sc* pSrcDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_64fc,
( const Ipp64f* pSrc, Ipp64fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_32fc,
( const Ipp32f* pSrc, Ipp32fc* pDst, int lenDst ))
IPPAPI ( IppStatus, ippsConjPerm_16sc,
( const Ipp16s* pSrc, Ipp16sc* pDst, int lenDst ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert
// Purpose: Converts integer data to floating point data
// Parameters:
// pSrc pointer to integer data to be converted
// pDst pointer to the destination vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsConvert_8s16s,(const Ipp8s* pSrc,Ipp16s* pDst,int len))
IPPAPI(IppStatus,ippsConvert_16s32s,(const Ipp16s* pSrc, Ipp32s* pDst, int len))
IPPAPI(IppStatus,ippsConvert_32s16s,(const Ipp32s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus,ippsConvert_8s32f,(const Ipp8s* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_8u32f,(const Ipp8u* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_16s32f,(const Ipp16s* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_16u32f,(const Ipp16u* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_32s64f,(const Ipp32s* pSrc,Ipp64f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_32s32f,(const Ipp32s* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsConvert_64s64f,(const Ipp64s* pSrc,Ipp64f* pDst, Ipp32u len))
IPPAPI(IppStatus,ippsConvert_16s8s_Sfs,(const Ipp16s* pSrc, Ipp8s* pDst,
Ipp32u len, IppRoundMode rndMode, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert
// Purpose: convert floating point data to integer data
// Parameters:
// pSrc pointer to the input floating point data to be converted
// pDst pointer to destination vector
// len length of the vectors
// rndMode Rounding mode which can be ippRndZero or ippRndNear
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Note:
// an out-of-range result will be saturated
*/
IPPAPI(IppStatus,ippsConvert_32f8s_Sfs,(const Ipp32f* pSrc, Ipp8s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_32f8u_Sfs,(const Ipp32f* pSrc, Ipp8u* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_32f16s_Sfs,(const Ipp32f* pSrc, Ipp16s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_32f16u_Sfs,(const Ipp32f* pSrc, Ipp16u* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_64f32s_Sfs,(const Ipp64f* pSrc, Ipp32s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_32f32s_Sfs,(const Ipp32f* pSrc, Ipp32s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_64f16s_Sfs,(const Ipp64f* pSrc, Ipp16s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus,ippsConvert_64f64s_Sfs,(const Ipp64f* pSrc, Ipp64s* pDst,
Ipp32u len, IppRoundMode rndMode, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_32f64f
// Purpose: Converts floating point data Ipp32f
// to floating point data Ipp64f
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsConvert_32f64f,
( const Ipp32f* pSrc, Ipp64f* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_64f32f
// Purpose: Converts floating point data Ipp64f
// to floating point data Ipp32f
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Note:
// an out-of-range result will be saturated
*/
IPPAPI ( IppStatus, ippsConvert_64f32f,
( const Ipp64f* pSrc, Ipp32f* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert
// Purpose: Converts integer data to floating point data
// Parameters:
// pSrc pointer to integer data to be converted
// pDst pointer to the destination vector
// len length of the vectors
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsConvert_16s32f_Sfs,
( const Ipp16s* pSrc, Ipp32f* pDst, int len, int scaleFactor ))
IPPAPI ( IppStatus, ippsConvert_16s64f_Sfs,
( const Ipp16s* pSrc, Ipp64f* pDst, int len, int scaleFactor ))
IPPAPI ( IppStatus, ippsConvert_32s32f_Sfs,
( const Ipp32s* pSrc, Ipp32f* pDst, int len, int scaleFactor ))
IPPAPI ( IppStatus, ippsConvert_32s64f_Sfs,
( const Ipp32s* pSrc, Ipp64f* pDst, int len, int scaleFactor ))
IPPAPI( IppStatus, ippsConvert_32s16s_Sfs,
( const Ipp32s* pSrc, Ipp16s* pDst, int len,
int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert
// Purpose: Converts 24u data to 32u or 32f data.
// Converts 32u or 32f data to 24u data.
// Converts 24s data to 32s or 32f data.
// Converts 32s or 32f data to 24s data.
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsConvert_24u32u,
( const Ipp8u* pSrc, Ipp32u* pDst, int len ))
IPPAPI( IppStatus, ippsConvert_32u24u_Sfs,
( const Ipp32u* pSrc, Ipp8u* pDst, int len,
int scaleFactor ))
IPPAPI( IppStatus, ippsConvert_24u32f,
( const Ipp8u* pSrc, Ipp32f* pDst, int len ))
IPPAPI( IppStatus, ippsConvert_32f24u_Sfs,
( const Ipp32f* pSrc, Ipp8u* pDst, int len,
int scaleFactor ))
IPPAPI( IppStatus, ippsConvert_24s32s,
( const Ipp8u* pSrc, Ipp32s* pDst, int len ))
IPPAPI( IppStatus, ippsConvert_32s24s_Sfs,
( const Ipp32s* pSrc, Ipp8u* pDst, int len,
int scaleFactor ))
IPPAPI( IppStatus, ippsConvert_24s32f,
( const Ipp8u* pSrc, Ipp32f* pDst, int len ))
IPPAPI( IppStatus, ippsConvert_32f24s_Sfs,
( const Ipp32f* pSrc, Ipp8u* pDst, int len,
int scaleFactor ))
#if !defined( _OWN_BLDPCS )
typedef Ipp16s Ipp16f;
#endif
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_16s16f
// Purpose: Converts integer data to floating point data
// Parameters:
// pSrc pointer to integer data to be converted
// pDst pointer to the destination vector
// len length of the vectors
// rndMode Rounding mode which can be ippRndZero or ippRndNear
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsConvert_16s16f,(const Ipp16s* pSrc,Ipp16f* pDst,int len,IppRoundMode rndMode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_16f16s_Sfs
// Purpose: convert floating point data to integer data
// Parameters:
// pSrc pointer to the input floating point data to be converted
// pDst pointer to destination vector
// len length of the vectors
// rndMode Rounding mode which can be ippRndZero or ippRndNear
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Note:
// an out-of-range result will be saturated
*/
IPPAPI(IppStatus,ippsConvert_16f16s_Sfs,(const Ipp16f* pSrc,Ipp16s* pDst,int len,IppRoundMode rndMode,int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_32f16f
// Purpose: Converts floating point data Ipp32f
// to floating point data Ipp16f
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// rndMode Rounding mode which can be ippRndZero or ippRndNear
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsConvert_32f16f,(const Ipp32f* pSrc,Ipp16f* pDst,int len,IppRoundMode rndMode))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert_16f32f
// Purpose: Converts floating point data Ipp16f
// to floating point data Ipp32f
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsConvert_16f32f,(const Ipp16f* pSrc,Ipp32f* pDst,int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvert
// Purpose: convert integer data to integer data
// Parameters:
// pSrc pointer to the input integer data to be converted
// pDst pointer to destination vector
// len length of the vectors
// rndMode Rounding mode which can be ippRndZero or ippRndNear
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Note:
// an out-of-range result will be saturated
*/
IPPAPI(IppStatus,ippsConvert_64s32s_Sfs,(const Ipp64s* pSrc, Ipp32s* pDst,
int len, IppRoundMode rndMode, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsThreshold
// Purpose: execute threshold operation on every element of the vector
// Parameters:
// level level of the threshold operation
// pSrcDst pointer to the vector for in-place operation
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// relOp comparison mode, cmpLess or cmpGreater
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsThreshNegLevelErr negative level value in complex operation
// ippStsBadArgErr relOp is no cmpLess and no cmpGreater
// ippStsNoErr otherwise
// Notes:
// real data
// cmpLess : pDst[n] = pSrc[n] < level ? level : pSrc[n];
// cmpGreater : pDst[n] = pSrc[n] > level ? level : pSrc[n];
// complex data
// cmpLess : pDst[n] = abs(pSrc[n]) < level ? pSrc[n]*k : pSrc[n];
// cmpGreater : pDst[n] = abs(pSrc[n]) > level ? pSrc[n]*k : pSrc[n];
// where k = level / abs(pSrc[n]);
*/
IPPAPI(IppStatus,ippsThreshold_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_32fc_I,( Ipp32fc* pSrcDst, int len,
Ipp32f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_64fc_I,( Ipp64fc* pSrcDst, int len,
Ipp64f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_16sc_I,( Ipp16sc* pSrcDst, int len,
Ipp16s level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_32f,( const Ipp32f* pSrc, Ipp32f* pDst,
int len, Ipp32f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_64f,( const Ipp64f* pSrc, Ipp64f* pDst,
int len, Ipp64f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64f level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s level, IppCmpOp relOp ))
IPPAPI(IppStatus,ippsThreshold_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16s level, IppCmpOp relOp))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsThresholdLT
// ippsThresholdGT
// Purpose: execute threshold operation on every element of the vector,
// "less than" for ippsThresoldLT
// "greater than for ippsThresholdGT
// Parameters:
// pSrcDst pointer to the vector for in-place operation
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// level level of the threshold operation
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsThreshNegLevelErr negative level value in complex operation
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsThreshold_LT_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_LT_32fc_I,( Ipp32fc* pSrcDst, int len,
Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_LT_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_LT_64fc_I,( Ipp64fc* pSrcDst, int len,
Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_LT_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_LT_16sc_I,( Ipp16sc* pSrcDst, int len,
Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_LT_32f,( const Ipp32f* pSrc, Ipp32f* pDst,
int len, Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_LT_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_LT_64f,( const Ipp64f* pSrc, Ipp64f* pDst,
int len, Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_LT_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_LT_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_LT_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_LT_32s_I,(Ipp32s* pSrcDst,int len,Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_LT_32s,(const Ipp32s* pSrc,Ipp32s* pDst,int len,Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_GT_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_GT_32fc_I,( Ipp32fc* pSrcDst, int len,
Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_GT_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_GT_64fc_I,( Ipp64fc* pSrcDst, int len,
Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_GT_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_GT_16sc_I,( Ipp16sc* pSrcDst, int len,
Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_GT_32f,( const Ipp32f* pSrc, Ipp32f* pDst,
int len, Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_GT_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32f level ))
IPPAPI(IppStatus,ippsThreshold_GT_64f,( const Ipp64f* pSrc, Ipp64f* pDst,
int len, Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_GT_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64f level ))
IPPAPI(IppStatus,ippsThreshold_GT_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s level ))
IPPAPI(IppStatus,ippsThreshold_GT_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16s level ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsThreshold_LTAbs
// ippsThreshold_GTAbs
// Purpose: execute threshold by abolute value operation on every element
// of the vector
// "less than" for ippsThresold_LTAbs
// "greater than for ippsThreshold_GTAbs
// Parameters:
// pSrcDst pointer to the vector for in-place operation
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// level level of the threshold operation
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsThreshNegLevelErr negative level value in complex operation
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsThreshold_LTAbs_32f,(const Ipp32f* pSrc, Ipp32f *pDst,
int len, Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_64f,(const Ipp64f* pSrc, Ipp64f *pDst,
int len, Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_16s,(const Ipp16s* pSrc, Ipp16s *pDst,
int len, Ipp16s level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_32s,(const Ipp32s* pSrc, Ipp32s *pDst,
int len, Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_32f_I,(Ipp32f *pSrcDst,
int len, Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_64f_I,(Ipp64f *pSrcDst,
int len, Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_16s_I,(Ipp16s *pSrcDst,
int len, Ipp16s level))
IPPAPI(IppStatus,ippsThreshold_LTAbs_32s_I,(Ipp32s *pSrcDst,
int len, Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_32f,(const Ipp32f* pSrc, Ipp32f *pDst,
int len, Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_64f,(const Ipp64f* pSrc, Ipp64f *pDst,
int len, Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_16s,(const Ipp16s* pSrc, Ipp16s *pDst,
int len, Ipp16s level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_32s,(const Ipp32s* pSrc, Ipp32s *pDst,
int len, Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_32f_I,(Ipp32f *pSrcDst,
int len, Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_64f_I,(Ipp64f *pSrcDst,
int len, Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_16s_I,(Ipp16s *pSrcDst,
int len, Ipp16s level))
IPPAPI(IppStatus,ippsThreshold_GTAbs_32s_I,(Ipp32s *pSrcDst,
int len, Ipp32s level))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsThresholdLTValue
// ippsThresholdGTValue
// Purpose: execute threshold operation on every element of the vector with
// replace on value,
// "less than" for ippsThresoldLTValue
// "greater than for ippsThresholdGTValue
// Parameters:
// pSrcDst pointer to the vector for in-place operation
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// level level of the threshold operation
// value value of replace
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsThreshNegLevelErr negative level value in complex operation
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsThreshold_LTVal_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f level, Ipp32f value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_32fc_I,( Ipp32fc* pSrcDst, int len,
Ipp32f level, Ipp32fc value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f level, Ipp64f value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_64fc_I,( Ipp64fc* pSrcDst, int len,
Ipp64f level, Ipp64fc value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s level, Ipp16s value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_16sc_I,( Ipp16sc* pSrcDst, int len,
Ipp16s level, Ipp16sc value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_32f,( const Ipp32f* pSrc, Ipp32f* pDst,
int len, Ipp32f level, Ipp32f value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32f level, Ipp32fc value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_64f,( const Ipp64f* pSrc, Ipp64f* pDst,
int len, Ipp64f level, Ipp64f value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64f level, Ipp64fc value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s level, Ipp16s value ))
IPPAPI(IppStatus,ippsThreshold_LTVal_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16s level, Ipp16sc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f level, Ipp32f value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_32fc_I,( Ipp32fc* pSrcDst, int len,
Ipp32f level, Ipp32fc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f level, Ipp64f value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_64fc_I,( Ipp64fc* pSrcDst, int len,
Ipp64f level, Ipp64fc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s level, Ipp16s value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_16sc_I,( Ipp16sc* pSrcDst, int len,
Ipp16s level, Ipp16sc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_32f,( const Ipp32f* pSrc, Ipp32f* pDst,
int len, Ipp32f level, Ipp32f value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32f level, Ipp32fc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_64f,( const Ipp64f* pSrc, Ipp64f* pDst,
int len, Ipp64f level, Ipp64f value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64f level, Ipp64fc value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s level, Ipp16s value ))
IPPAPI(IppStatus,ippsThreshold_GTVal_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16s level, Ipp16sc value ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsThresholdLTInv
//
// Purpose: replace elements of vector values by their inversion after
// threshold operation
// Parameters:
// level level of threshold operation
// pSrcDst pointer to the vector in in-place operation
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsThreshNegLevelErr negative level value
// ippStsInvZero level value and source element value are zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsThreshold_LTInv_32f_I,(Ipp32f* pSrcDst,int len,Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_32fc_I,(Ipp32fc* pSrcDst,int len,Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_64f_I,(Ipp64f* pSrcDst,int len,Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_64fc_I,(Ipp64fc* pSrcDst,int len,Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_32f,(const Ipp32f* pSrc,Ipp32f* pDst,int len,Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_32fc,(const Ipp32fc* pSrc,Ipp32fc* pDst,int len,Ipp32f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_64f,(const Ipp64f* pSrc,Ipp64f* pDst,int len,Ipp64f level))
IPPAPI(IppStatus,ippsThreshold_LTInv_64fc,(const Ipp64fc* pSrc,Ipp64fc* pDst,int len,Ipp64f level))
/* ///////////////////////////////////////////////////////////////////////////// */
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_32f_I,( Ipp32f* pSrcDst, int len,
Ipp32f levelLT, Ipp32f valueLT, Ipp32f levelGT, Ipp32f valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_64f_I,( Ipp64f* pSrcDst, int len,
Ipp64f levelLT, Ipp64f valueLT, Ipp64f levelGT, Ipp64f valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_32f,( const Ipp32f* pSrc,
Ipp32f* pDst, int len, Ipp32f levelLT, Ipp32f valueLT, Ipp32f levelGT,
Ipp32f valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_64f,( const Ipp64f* pSrc,
Ipp64f* pDst, int len, Ipp64f levelLT, Ipp64f valueLT, Ipp64f levelGT,
Ipp64f valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_16s_I,( Ipp16s* pSrcDst, int len,
Ipp16s levelLT, Ipp16s valueLT, Ipp16s levelGT, Ipp16s valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_16s,( const Ipp16s* pSrc,
Ipp16s* pDst, int len, Ipp16s levelLT, Ipp16s valueLT, Ipp16s levelGT,
Ipp16s valueGT ))
IPPAPI(IppStatus,ippsThreshold_GT_32s_I,(Ipp32s* pSrcDst,int len,Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_GT_32s,(const Ipp32s* pSrc,Ipp32s* pDst,int len,Ipp32s level))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_32s_I,( Ipp32s* pSrcDst, int len,
Ipp32s levelLT, Ipp32s valueLT, Ipp32s levelGT, Ipp32s valueGT ))
IPPAPI(IppStatus,ippsThreshold_LTValGTVal_32s,( const Ipp32s* pSrc,
Ipp32s* pDst, int len, Ipp32s levelLT, Ipp32s valueLT, Ipp32s levelGT, Ipp32s valueGT ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsCartToPolar
//
// Purpose: Convert cartesian coordinate to polar. Input data are formed as
// a complex vector.
//
// Parameters:
// pSrc an input complex vector
// pDstMagn an output vector to store the magnitude components
// pDstPhase an output vector to store the phase components (in radians)
// len a length of the array
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsCartToPolar_32fc,(const Ipp32fc* pSrc, Ipp32f* pDstMagn,
Ipp32f* pDstPhase, int len))
IPPAPI(IppStatus, ippsCartToPolar_64fc,(const Ipp64fc* pSrc, Ipp64f* pDstMagn,
Ipp64f* pDstPhase, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsCartToPolar
//
// Purpose: Convert cartesian coordinate to polar. Input data are formed as
// two real vectors.
//
// Parameters:
// pSrcRe an input vector containing the coordinates X
// pSrcIm an input vector containing the coordinates Y
// pDstMagn an output vector to store the magnitude components
// pDstPhase an output vector to store the phase components (in radians)
// len a length of the array
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsCartToPolar_32f,(const Ipp32f* pSrcRe, const Ipp32f*
pSrcIm, Ipp32f* pDstMagn, Ipp32f* pDstPhase, int len))
IPPAPI(IppStatus, ippsCartToPolar_64f,(const Ipp64f* pSrcRe, const Ipp64f*
pSrcIm, Ipp64f* pDstMagn, Ipp64f* pDstPhase, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsPolarToCart
//
// Purpose: Convert polar coordinate to cartesian. Output data are formed as
// a complex vector.
//
// Parameters:
// pDstMagn an input vector containing the magnitude components
// pDstPhase an input vector containing the phase components(in radians)
// pDst an output complex vector to store the cartesian coordinates
// len a length of the arrays
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsPolarToCart_32fc,(const Ipp32f* pSrcMagn,
const Ipp32f* pSrcPhase, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsPolarToCart_64fc,(const Ipp64f* pSrcMagn,
const Ipp64f* pSrcPhase, Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsPolarToCart_32sc,(const Ipp32s* pSrcMagn,
const Ipp32s* pSrcPhase, int phaseFixedPoint, Ipp32sc* pDst, int len))
IPPAPI(IppStatus, ippsPolarToCart_16sc,(const Ipp16s* pSrcMagn,
const Ipp16s* pSrcPhase, int phaseFixedPoint, Ipp16sc* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsPolarToCart
//
// Purpose: Convert polar coordinate to cartesian. Output data are formed as
// two real vectors.
//
// Parameters:
// pDstMagn an input vector containing the magnitude components
// pDstPhase an input vector containing the phase components(in radians)
// pSrcRe an output complex vector to store the coordinates X
// pSrcIm an output complex vector to store the coordinates Y
// len a length of the arrays
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsPolarToCart_32f,(const Ipp32f* pSrcMagn,
const Ipp32f* pSrcPhase, Ipp32f* pDstRe, Ipp32f* pDstIm, int len))
IPPAPI(IppStatus, ippsPolarToCart_64f,(const Ipp64f* pSrcMagn,
const Ipp64f* pSrcPhase, Ipp64f* pDstRe, Ipp64f* pDstIm, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsCartToPolar
//
// Purpose: Convert cartesian coordinate to polar. Input data are formed as
// a complex vector.
//
// Parameters:
// pSrc an input complex vector
// pDstMagn an output vector to store the magnitude components
// pDstPhase an output vector to store the phase components (in radians)
// len a length of the array
// magnScaleFactor scale factor of the magnitude companents
// phaseScaleFactor scale factor of the phase companents
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsCartToPolar_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16s* pDstMagn, Ipp16s* pDstPhase, int len, int magnScaleFactor, int phaseScaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsPolarToCart
//
// Purpose: Convert polar coordinate to cartesian. Output data are formed as
// a complex vector.
//
// Parameters:
// pDstMagn an input vector containing the magnitude components
// pDstPhase an input vector containing the phase components(in radians)
// pDst an output complex vector to store the cartesian coordinates
// len a length of the arrays
// magnScaleFactor scale factor of the magnitude companents
// phaseScaleFactor scale factor of the phase companents
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
//
*/
IPPAPI(IppStatus, ippsPolarToCart_16sc_Sfs, (const Ipp16s* pSrcMagn, const Ipp16s* pSrcPhase, Ipp16sc* pDst, int len, int magnScaleFactor, int phaseScaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Companding functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALawToLin
// Purpose: convert from A-Law to linear PCM value
// Parameters:
// pSrc pointer to the input vector containing A-Law values
// pDst pointer to the output vector for store linear PCM values
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsALawToLin_8u32f, (const Ipp8u* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsALawToLin_8u16s, (const Ipp8u* pSrc, Ipp16s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMuLawToLin
// Purpose: convert from Mu-Law to linear PCM value
// Parameters:
// pSrc pointer to the input vector containing Mu-Law values
// pDst pointer to the output vector for store linear PCM values
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsMuLawToLin_8u32f, (const Ipp8u* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsMuLawToLin_8u16s, (const Ipp8u* pSrc, Ipp16s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsLinToALaw
// Purpose: convert from linear PCM to A-Law value
// Parameters:
// pSrc pointer to the input vector containing linear PCM values
// pDst pointer to the output vector for store A-Law values
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsLinToALaw_32f8u, (const Ipp32f* pSrc, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsLinToALaw_16s8u, (const Ipp16s* pSrc, Ipp8u* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsMuLawToLin
// Purpose: convert from linear PCM to Mu-Law value
// Parameters:
// pSrc pointer to the input vector containing linear PCM values
// pDst pointer to the output vector for store Mu-Law values
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsLinToMuLaw_32f8u, (const Ipp32f* pSrc, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsLinToMuLaw_16s8u, (const Ipp16s* pSrc, Ipp8u* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsALawToMuLaw, ippsMuLawToALaw
// Purpose: convert from A-Law to Mu-Law and vice-versa
// Parameters:
// pSrc pointer to the input vector containing A-Law or Mu-Law values
// pDst pointer to the output vector for store Mu-Law or A-Law values
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsALawToMuLaw_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsMuLawToALaw_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPreemphasize_32f
// Purpose:
// Compute the preemphasizes a single precision real signal.
// Parameters:
// pSrcDst pointer to the vector for in-place operation.
// len length of the input vector.
// val The multiplier to be used in the preemphasis difference equation
// y(n) = x(n) - a * x(n-1) where y is the preemphasized output
// and x is the input. Usually a value of 0.95 is used for speech
// audio signals.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
*/
IPPAPI(IppStatus, ippsPreemphasize_32f,(Ipp32f* pSrcDst, int len, Ipp32f val))
IPPAPI(IppStatus, ippsPreemphasize_16s,(Ipp16s* pSrcDst, int len, Ipp32f val))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFlip
// Purpose: dst[i] = src[len-i-1], i=0..len-1
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors, number of items
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFlip_8u,( const Ipp8u* pSrc, Ipp8u* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_8u_I,( Ipp8u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsFlip_16u,( const Ipp16u* pSrc, Ipp16u* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_16u_I,( Ipp16u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsFlip_32f,( const Ipp32f* pSrc, Ipp32f* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_32f_I,( Ipp32f* pSrcDst, int len ))
IPPAPI(IppStatus, ippsFlip_64f,( const Ipp64f* pSrc, Ipp64f* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_64f_I,( Ipp64f* pSrcDst, int len ))
IPPAPI(IppStatus, ippsFlip_32fc,( const Ipp32fc* pSrc, Ipp32fc* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_32fc_I,( Ipp32fc* pSrcDst, int len ))
IPPAPI(IppStatus, ippsFlip_64fc,( const Ipp64fc* pSrc, Ipp64fc* pDst, int len ))
IPPAPI(IppStatus, ippsFlip_64fc_I,( Ipp64fc* pSrcDst, int len ))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsUpdateLinear_16s32s_I
// Purpose: Calc Update Linear value
// Return:
// IPP_NO_ERR Ok
// IPP_NULL_PTR_ERR Pointer to pSrc or pointer to pSrcDst is NULL
// IPP_BADSIZE_ERR The length of the array is less or equal zero
// Parameters:
// pSrc pointer to vector
// len a length of the array
// pSrcDst pointer to input and output
// srcShiftRight shiftright of src (0<=srcShiftRight<=15)
// alpha weight
// hint code specific use hints
//
*/
IPPAPI(IppStatus,ippsUpdateLinear_16s32s_I,(const Ipp16s* pSrc,int len,
Ipp32s* pSrcDst, int srcShiftRight,Ipp16s alpha, IppHintAlgorithm hint))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsUpdatePower_16s32s_I
// Purpose: Calc Update Power value
// Return:
// IPP_NO_ERR Ok
// IPP_NULL_PTR_ERR Pointer to pSrc or pointer to pSrcDst is NULL
// IPP_BADSIZE_ERR The length of the array is less or equal zero
// Parameters:
// pSrc pointer to vector
// len a length of the array
// pSrcDst pointer to input and output
// srcShiftRight shiftright of src (0<=srcShiftRight<=31)
// alpha weight
// hint code specific use hints
//
*/
IPPAPI(IppStatus,ippsUpdatePower_16s32s_I,(const Ipp16s* pSrc,int len,
Ipp32s* pSrcDst, int srcShiftRight,Ipp16s alpha, IppHintAlgorithm hint))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsJoin_32f16s_D2L
// Purpose: Join of vectors.
// Parameters:
// pSrc pointer to pointers to the input vectors
// pDst pointer to the output vector
// nChannels number of channels
// chanlen length of the channel
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr nChannels or chanlen are less or equal zero
// ippStsNoErr otherwise
//
*/
IPPAPI( IppStatus, ippsJoin_32f16s_D2L, ( const Ipp32f** pSrc,
int nChannels, int chanLen, Ipp16s* pDst ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsJoinScaled_32f16s_D2L
// ippsJoinScaled_32f24s_D2L
//
// Purpose: Join of vectors.
// Parameters:
// pSrc pointer to pointers to the input vectors
// pDst pointer to the output vector
// nChannels number of channels
// chanlen length of the channel
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr nChannels or chanlen are less or equal zero
// ippStsNoErr otherwise
//
// Note: Default region of the src data is [-1.0,1.0].
*/
IPPAPI( IppStatus, ippsJoinScaled_32f16s_D2L,
( const Ipp32f** pSrc, int nChannels, int chanLen, Ipp16s* pDst ) )
IPPAPI( IppStatus, ippsJoinScaled_32f24s_D2L,
( const Ipp32f** pSrc, int nChannels, int chanLen, Ipp8u* pDst ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSplitScaled_16s32f_D2L
// ippsSplitScaled_24s32f_D2L
//
// Purpose: Split of vector.
// Parameters:
// pSrc pointer to the input vector
// pDst pointer to pointers to the output vectors
// nChannels number of channels
// chanlen length of the channel
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr nChannels or chanlen are less or equal zero
// ippStsNoErr otherwise
//
// Note: Region of the dst data is [-1.0,1.0].
*/
IPPAPI( IppStatus, ippsSplitScaled_16s32f_D2L,
( const Ipp16s* pSrc, Ipp32f** pDst, int nChannels, int chanLen ) )
IPPAPI( IppStatus, ippsSplitScaled_24s32f_D2L,
( const Ipp8u* pSrc, Ipp32f** pDst, int nChannels, int chanLen ) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSwapBytes
// Purpose: switches from a "big endian" order to the "little endian" order and vice-versa
// Parameters:
// pSrc pointer to the source vector
// pSrcDst pointer to the source/destination vector
// pDst pointer to the destination vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsSwapBytes_16u_I, ( Ipp16u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_24u_I, ( Ipp8u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_32u_I, ( Ipp32u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_64u_I, ( Ipp64u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_16u, ( const Ipp16u* pSrc, Ipp16u* pDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_24u, ( const Ipp8u* pSrc, Ipp8u* pDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_32u, ( const Ipp32u* pSrc, Ipp32u* pDst, int len ))
IPPAPI(IppStatus, ippsSwapBytes_64u, ( const Ipp64u* pSrc, Ipp64u* pDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Arithmetic functions
///////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsAdd, ippsSub, ippsMul
//
// Purpose: add, subtract and multiply operations upon every element of
// the source vector
// Arguments:
// pSrc pointer to the source vector
// pSrcDst pointer to the source/destination vector
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// pDst pointer to the destination vector
// len length of the vectors
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
// Note:
// AddC(X,v,Y) : Y[n] = X[n] + v
// MulC(X,v,Y) : Y[n] = X[n] * v
// SubC(X,v,Y) : Y[n] = X[n] - v
// SubCRev(X,v,Y) : Y[n] = v - X[n]
// Sub(X,Y) : Y[n] = Y[n] - X[n]
// Sub(X,Y,Z) : Z[n] = Y[n] - X[n]
*/
IPPAPI(IppStatus, ippsAddC_16s_I, (Ipp16s val, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubC_16s_I, (Ipp16s val, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_16s_I, (Ipp16s val, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsAddC_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsAddC_32fc_I, (Ipp32fc val, Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubC_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubC_32fc_I, (Ipp32fc val, Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubCRev_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubCRev_32fc_I, (Ipp32fc val, Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_32fc_I, (Ipp32fc val, Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsAddC_64f_I, (Ipp64f val, Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsAddC_64fc_I, (Ipp64fc val, Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubC_64f_I, (Ipp64f val, Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubC_64fc_I, (Ipp64fc val, Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubCRev_64f_I, (Ipp64f val, Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSubCRev_64fc_I, (Ipp64fc val, Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_64f_I, (Ipp64f val, Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_64fc_I, (Ipp64fc val, Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsMulC_32f16s_Sfs, (const Ipp32f* pSrc, Ipp32f val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_Low_32f16s, (const Ipp32f* pSrc, Ipp32f val,
Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsAddC_8u_ISfs, (Ipp8u val, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_8u_ISfs, (Ipp8u val, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_8u_ISfs, (Ipp8u val, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_8u_ISfs, (Ipp8u val, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_16sc_ISfs, (Ipp16sc val, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16sc_ISfs, (Ipp16sc val, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16sc_ISfs, (Ipp16sc val, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16sc_ISfs, (Ipp16sc val, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_32s_ISfs, (Ipp32s val, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_32sc_ISfs, (Ipp32sc val, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_32s_ISfs, (Ipp32s val, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_32sc_ISfs, (Ipp32sc val, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_32s_ISfs, (Ipp32s val, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_32sc_ISfs, (Ipp32sc val, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_32s_ISfs, (Ipp32s val, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_32sc_ISfs, (Ipp32sc val, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsAddC_32fc, (const Ipp32fc* pSrc, Ipp32fc val,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsSubC_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsSubC_32fc, (const Ipp32fc* pSrc, Ipp32fc val,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsSubCRev_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsSubCRev_32fc, (const Ipp32fc* pSrc, Ipp32fc val,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsMulC_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsMulC_32fc, (const Ipp32fc* pSrc, Ipp32fc val,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsAddC_64f, (const Ipp64f* pSrc, Ipp64f val,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsAddC_64fc, (const Ipp64fc* pSrc, Ipp64fc val,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsSubC_64f, (const Ipp64f* pSrc, Ipp64f val,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsSubC_64fc, (const Ipp64fc* pSrc, Ipp64fc val,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsSubCRev_64f, (const Ipp64f* pSrc, Ipp64f val,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsSubCRev_64fc, (const Ipp64fc* pSrc, Ipp64fc val,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsMulC_64f, (const Ipp64f* pSrc, Ipp64f val,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsMulC_64fc, (const Ipp64fc* pSrc, Ipp64fc val,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsAddC_8u_Sfs, (const Ipp8u* pSrc, Ipp8u val,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_8u_Sfs, (const Ipp8u* pSrc, Ipp8u val,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_8u_Sfs, (const Ipp8u* pSrc, Ipp8u val,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_8u_Sfs, (const Ipp8u* pSrc, Ipp8u val,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc val,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc val,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16sc_Sfs,(const Ipp16sc* pSrc, Ipp16sc val,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc val,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_32s_Sfs, (const Ipp32s* pSrc, Ipp32s val,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc val,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_32s_Sfs, (const Ipp32s* pSrc, Ipp32s val,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc val,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_32s_Sfs, (const Ipp32s* pSrc, Ipp32s val,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_32sc_Sfs,(const Ipp32sc* pSrc, Ipp32sc val,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_32s_Sfs, (const Ipp32s* pSrc, Ipp32s val,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc val,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16s_I, (const Ipp16s* pSrc,
Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSub_16s_I, (const Ipp16s* pSrc,
Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMul_16s_I, (const Ipp16s* pSrc,
Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsAdd_32f_I, (const Ipp32f* pSrc,
Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsAdd_32fc_I, (const Ipp32fc* pSrc,
Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSub_32f_I, (const Ipp32f* pSrc,
Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSub_32fc_I, (const Ipp32fc* pSrc,
Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsMul_32f_I, (const Ipp32f* pSrc,
Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMul_32fc_I, (const Ipp32fc* pSrc,
Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsAdd_64f_I, (const Ipp64f* pSrc,
Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsAdd_64fc_I, (const Ipp64fc* pSrc,
Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsSub_64f_I, (const Ipp64f* pSrc,
Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSub_64fc_I, (const Ipp64fc* pSrc,
Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsMul_64f_I, (const Ipp64f* pSrc,
Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMul_64fc_I, (const Ipp64fc* pSrc,
Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsAdd_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16sc_ISfs, (const Ipp16sc* pSrc, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16sc_ISfs, (const Ipp16sc* pSrc, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16sc_ISfs, (const Ipp16sc* pSrc, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_32s_ISfs, (const Ipp32s* pSrc, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_32sc_ISfs, (const Ipp32sc* pSrc, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_32s_ISfs, (const Ipp32s* pSrc, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_32sc_ISfs, (const Ipp32sc* pSrc, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32s_ISfs, (const Ipp32s* pSrc, Ipp32s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32sc_ISfs, (const Ipp32sc* pSrc, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_8u16u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsMul_8u16u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsAdd_16s, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsSub_16s, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsMul_16s, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsAdd_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsAdd_32u, (const Ipp32u* pSrc1, const Ipp32u* pSrc2,
Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsAdd_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsSub_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsMul_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsAdd_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsAdd_32fc, (const Ipp32fc* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsSub_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsSub_32fc, (const Ipp32fc* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsMul_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsMul_32fc, (const Ipp32fc* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsAdd_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsAdd_64fc, (const Ipp64fc* pSrc1, const Ipp64fc* pSrc2,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsSub_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsSub_64fc, (const Ipp64fc* pSrc1, const Ipp64fc* pSrc2,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsMul_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsMul_64fc, (const Ipp64fc* pSrc1, const Ipp64fc* pSrc2,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsAdd_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16sc_Sfs, (const Ipp16sc* pSrc1, const Ipp16sc* pSrc2,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16sc_Sfs, (const Ipp16sc* pSrc1, const Ipp16sc* pSrc2,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16sc_Sfs, (const Ipp16sc* pSrc1, const Ipp16sc* pSrc2,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16s32s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_32s_Sfs, (const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_64s_Sfs, (const Ipp64s* pSrc1, const Ipp64s* pSrc2,
Ipp64s* pDst, Ipp32u len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_32sc_Sfs, (const Ipp32sc* pSrc1, const Ipp32sc* pSrc2,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_32s_Sfs, (const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_32sc_Sfs, (const Ipp32sc* pSrc1, const Ipp32sc* pSrc2,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32s_Sfs, (const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32sc_Sfs, (const Ipp32sc* pSrc1, const Ipp32sc* pSrc2,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16u16s_Sfs, (const Ipp16u* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32s32sc_ISfs, (const Ipp32s* pSrc, Ipp32sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32s32sc_Sfs, (const Ipp32s* pSrc1, const Ipp32sc* pSrc2,
Ipp32sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_Low_32s_Sfs, ( const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_32f32fc_I, (const Ipp32f* pSrc, Ipp32fc* pSrcDst,
int len))
IPPAPI(IppStatus, ippsMul_32f32fc, (const Ipp32f* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsAdd_16s32s_I, (const Ipp16s* pSrc, Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsAddC_16u_ISfs, (Ipp16u val, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAddC_16u_Sfs, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16u_ISfs, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsAdd_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16u_ISfs, (Ipp16u val, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubC_16u_Sfs, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16u_ISfs, (Ipp16u val, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSubCRev_16u_Sfs, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16u_ISfs, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsSub_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16u_ISfs, (Ipp16u val, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_16u_Sfs, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16u_ISfs, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMul_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_64s_ISfs, (Ipp64s val, Ipp64s* pSrcDst, Ipp32u len, int scaleFactor))
IPPAPI(IppStatus, ippsMulC_64f64s_ISfs, (Ipp64f val, Ipp64s* pSrcDst, Ipp32u len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAddProduct
// Purpose: multiplies elements of two source vectors and adds product to
// the accumulator vector
// Parameters:
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// pSrcDst pointer to the source/destination (accumulator) vector
// len length of the vectors
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
//
// Notes: pSrcDst[n] = pSrcDst[n] + pSrc1[n] * pSrc2[n], n=0,1,2,..len-1.
*/
IPPAPI(IppStatus, ippsAddProduct_16s_Sfs, ( const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pSrcDst, int len, int scaleFactor ))
IPPAPI(IppStatus, ippsAddProduct_16s32s_Sfs, ( const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp32s* pSrcDst, int len, int scaleFactor ))
IPPAPI(IppStatus, ippsAddProduct_32s_Sfs, ( const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pSrcDst, int len, int scaleFactor ))
IPPAPI(IppStatus, ippsAddProduct_32f, ( const Ipp32f* pSrc1, const Ipp32f* pSrc2,
Ipp32f* pSrcDst, int len ))
IPPAPI(IppStatus, ippsAddProduct_64f, ( const Ipp64f* pSrc1, const Ipp64f* pSrc2,
Ipp64f* pSrcDst, int len ))
IPPAPI(IppStatus, ippsAddProduct_32fc, ( const Ipp32fc* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pSrcDst, int len ))
IPPAPI(IppStatus, ippsAddProduct_64fc, ( const Ipp64fc* pSrc1, const Ipp64fc* pSrc2,
Ipp64fc* pSrcDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsSqr
// Purpose: compute square value for every element of the source vector
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the input vector
// pDst pointer to the output vector
// len length of the vectors
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) the source data NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsSqr_32f_I,(Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus,ippsSqr_32fc_I,(Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus,ippsSqr_64f_I,(Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus,ippsSqr_64fc_I,(Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus,ippsSqr_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus,ippsSqr_32fc,(const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus,ippsSqr_64f,(const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus,ippsSqr_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
IPPAPI(IppStatus,ippsSqr_16s_ISfs,(Ipp16s* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqr_16sc_ISfs,(Ipp16sc* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqr_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqr_16sc_Sfs,(const Ipp16sc* pSrc, Ipp16sc* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqr_8u_ISfs,(Ipp8u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqr_8u_Sfs,(const Ipp8u* pSrc, Ipp8u* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqr_16u_ISfs,(Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqr_16u_Sfs,(const Ipp16u* pSrc, Ipp16u* pDst, int len,
int scaleFactor))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsDiv
//
// Purpose: divide every element of the source vector by the scalar value
// or by corresponding element of the second source vector
// Arguments:
// val the divisor value
// pSrc pointer to the divisor source vector
// pSrc1 pointer to the divisor source vector
// pSrc2 pointer to the dividend source vector
// pDst pointer to the destination vector
// pSrcDst pointer to the source/destination vector
// len vector's length, number of items
// scaleFactor scale factor parameter value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsDivByZeroErr the scalar divisor value is zero
// ippStsDivByZero Warning status if an element of divisor vector is
// zero. If the dividend is zero than result is
// NaN, if the dividend is not zero than result
// is Infinity with correspondent sign. The
// execution is not aborted. For the integer operation
// zero instead of NaN and the corresponding bound
// values instead of Infinity
// ippStsNoErr otherwise
// Note:
// DivC(v,X,Y) : Y[n] = X[n] / v
// DivC(v,X) : X[n] = X[n] / v
// Div(X,Y) : Y[n] = Y[n] / X[n]
// Div(X,Y,Z) : Z[n] = Y[n] / X[n]
*/
IPPAPI(IppStatus, ippsDiv_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsDiv_32fc, (const Ipp32fc* pSrc1, const Ipp32fc* pSrc2,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsDiv_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsDiv_64fc, (const Ipp64fc* pSrc1, const Ipp64fc* pSrc2,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsDiv_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_16sc_Sfs, (const Ipp16sc* pSrc1,
const Ipp16sc* pSrc2, Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsDivC_32fc, (const Ipp32fc* pSrc, Ipp32fc val,
Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsDivC_64f, (const Ipp64f* pSrc, Ipp64f val,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsDivC_64fc, (const Ipp64fc* pSrc, Ipp64fc val,
Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsDivC_16s_Sfs, (const Ipp16s* pSrc, Ipp16s val,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_8u_Sfs, (const Ipp8u* pSrc, Ipp8u val,
Ipp8u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc val,
Ipp16sc* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_32f_I, (const Ipp32f* pSrc,
Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsDiv_32fc_I, (const Ipp32fc* pSrc,
Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsDiv_64f_I, (const Ipp64f* pSrc,
Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsDiv_64fc_I, (const Ipp64fc* pSrc,
Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsDiv_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_16sc_ISfs, (const Ipp16sc* pSrc, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_32s_Sfs, (const Ipp32s* pSrc1, const Ipp32s* pSrc2,
Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_32s_ISfs, (const Ipp32s* pSrc, Ipp32s* pSrcDst,
int len, int ScaleFactor))
IPPAPI(IppStatus, ippsDiv_32s16s_Sfs, (const Ipp16s* pSrc1, const Ipp32s* pSrc2,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivC_32fc_I, (Ipp32fc val, Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivC_64f_I, (Ipp64f val, Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivC_64fc_I, (Ipp64fc val, Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivC_16s_ISfs, (Ipp16s val, Ipp16s* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_8u_ISfs, (Ipp8u val, Ipp8u* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_16sc_ISfs, (Ipp16sc val, Ipp16sc* pSrcDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivCRev_16u, (const Ipp16u* pSrc, Ipp16u val,
Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsDivCRev_32f, (const Ipp32f* pSrc, Ipp32f val,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsDivCRev_16u_I, (Ipp16u val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivCRev_32f_I, (Ipp32f val, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsDivC_16u_ISfs, (Ipp16u val, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDivC_16u_Sfs, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_16u_ISfs, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len, int scaleFactor))
IPPAPI( IppStatus, ippsDivC_64s_ISfs, ( Ipp64s val, Ipp64s* pSrcDst, Ipp32u len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsSqrt
// Purpose: compute square root value for every element of the source vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// pSrcDst pointer to the source/destination vector
// len length of the vector(s), number of items
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to vector is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsSqrtNegArg negative value in real sequence
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsSqrt_32f_I,(Ipp32f* pSrcDst,int len))
IPPAPI(IppStatus,ippsSqrt_32fc_I,(Ipp32fc* pSrcDst,int len))
IPPAPI(IppStatus,ippsSqrt_64f_I,(Ipp64f* pSrcDst,int len))
IPPAPI(IppStatus,ippsSqrt_64fc_I,(Ipp64fc* pSrcDst,int len))
IPPAPI(IppStatus,ippsSqrt_32f,(const Ipp32f* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsSqrt_32fc,(const Ipp32fc* pSrc,Ipp32fc* pDst,int len))
IPPAPI(IppStatus,ippsSqrt_64f,(const Ipp64f* pSrc,Ipp64f* pDst,int len))
IPPAPI(IppStatus,ippsSqrt_64fc,(const Ipp64fc* pSrc,Ipp64fc* pDst,int len))
IPPAPI(IppStatus,ippsSqrt_16s_ISfs,(Ipp16s* pSrcDst,int len,int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_16sc_ISfs,(Ipp16sc* pSrcDst,int len,int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_16s_Sfs,(const Ipp16s* pSrc,Ipp16s* pDst,int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_16sc_Sfs,(const Ipp16sc* pSrc,Ipp16sc* pDst,int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_64s_ISfs,(Ipp64s* pSrcDst,int len,int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_64s_Sfs,(const Ipp64s* pSrc,Ipp64s* pDst,int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_8u_ISfs,(Ipp8u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_8u_Sfs,(const Ipp8u* pSrc, Ipp8u* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_16u_ISfs,(Ipp16u* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_16u_Sfs,(const Ipp16u* pSrc, Ipp16u* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_32s16s_Sfs,(const Ipp32s* pSrc,Ipp16s* pDst,
int len, int scaleFactor))
IPPAPI(IppStatus,ippsSqrt_64s16s_Sfs,(const Ipp64s* pSrc,Ipp16s* pDst,
int len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsCubrt
// Purpose: Compute cube root of every elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s)
// ScaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector(s) is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsCubrt_32s16s_Sfs, ( const Ipp32s* pSrc, Ipp16s* pDst, int Len, int sFactor))
IPPAPI(IppStatus, ippsCubrt_32f, ( const Ipp32f* pSrc, Ipp32f* pDst, int Len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsAbs
// Purpose: compute absolute value of each element of the source vector
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s), number of items
// Return:
// ippStsNullPtrErr pointer(s) to data vector is NULL
// ippStsSizeErr length of a vector is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsAbs_32f_I,(Ipp32f* pSrcDst,int len))
IPPAPI(IppStatus,ippsAbs_64f_I,(Ipp64f* pSrcDst,int len))
IPPAPI(IppStatus,ippsAbs_16s_I,(Ipp16s* pSrcDst,int len))
IPPAPI(IppStatus,ippsAbs_32f,(const Ipp32f* pSrc, Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsAbs_64f,(const Ipp64f* pSrc, Ipp64f* pDst,int len))
IPPAPI(IppStatus,ippsAbs_16s,(const Ipp16s* pSrc, Ipp16s* pDst,int len))
IPPAPI(IppStatus,ippsAbs_32s_I,(Ipp32s* pSrcDst,int len))
IPPAPI(IppStatus,ippsAbs_32s,(const Ipp32s* pSrc, Ipp32s* pDst,int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMagnitude
// Purpose: compute magnitude of every complex element of the source
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s), number of items
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to data vector is NULL
// ippStsSizeErr length of a vector is less or equal 0
// ippStsNoErr otherwise
// Notes:
// dst = sqrt( src.re^2 + src.im^2 )
*/
IPPAPI(IppStatus,ippsMagnitude_32fc, (const Ipp32fc* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsMagnitude_64fc, (const Ipp64fc* pSrc,Ipp64f* pDst,int len))
IPPAPI(IppStatus,ippsMagnitude_16sc32f,(const Ipp16sc* pSrc,Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsMagnitude_16sc_Sfs,(const Ipp16sc* pSrc,Ipp16s* pDst,
int len,int scaleFactor))
IPPAPI(IppStatus,ippsMagnitude_32f,(const Ipp32f* pSrcRe,const Ipp32f* pSrcIm,
Ipp32f* pDst,int len))
IPPAPI(IppStatus,ippsMagnitude_64f,(const Ipp64f* pSrcRe,const Ipp64f* pSrcIm,
Ipp64f* pDst,int len))
IPPAPI(IppStatus,ippsMagnitude_16s_Sfs,(const Ipp16s* pSrcRe,const Ipp16s* pSrcIm,
Ipp16s* pDst,int len,int scaleFactor))
IPPAPI(IppStatus,ippsMagnitude_32sc_Sfs,(const Ipp32sc* pSrc,Ipp32s* pDst,
int len,int scaleFactor))
IPPAPI(IppStatus,ippsMagnitude_16s32f,(const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsMagSquared_32sc32s_Sfs, (const Ipp32sc* pSrc, Ipp32s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsMagSquared_32fc64f, (const Ipp32fc* pSrc, Ipp64f* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsExp
// Purpose: compute exponent value for all elements of the source vector
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s)
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector(s) is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsExp_32f_I,(Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsExp_64f_I,(Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsExp_16s_ISfs,(Ipp16s* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsExp_32s_ISfs,(Ipp32s* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsExp_64s_ISfs,(Ipp64s* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsExp_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsExp_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsExp_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus, ippsExp_32s_Sfs,(const Ipp32s* pSrc, Ipp32s* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus, ippsExp_64s_Sfs,(const Ipp64s* pSrc, Ipp64s* pDst, int len,
int scaleFactor))
IPPAPI(IppStatus, ippsExp_32f64f,(const Ipp32f* pSrc, Ipp64f* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsLn
// Purpose: compute natural logarithm of every elements of the source vector
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s)
// ScaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector(s) is less or equal 0
// ippStsLnZeroArg zero value in the source vector
// ippStsLnNegArg negative value in the source vector
// ippStsNoErr otherwise
// Notes:
// Ln( x<0 ) = NaN
// Ln( 0 ) = -Inf
*/
IPPAPI(IppStatus, ippsLn_32f_I,(Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsLn_64f_I,(Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsLn_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsLn_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsLn_64f32f,(const Ipp64f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsLn_16s_ISfs,(Ipp16s* pSrcDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsLn_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsLn_32s16s_Sfs, ( const Ipp32s* pSrc, Ipp16s* pDst, int Len, int scaleFactor))
IPPAPI(IppStatus, ippsLn_32s_ISfs,( Ipp32s* pSrcDst, int Len, int scaleFactor))
IPPAPI(IppStatus, ippsLn_32s_Sfs, ( const Ipp32s* pSrc, Ipp32s* pDst, int Len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipps10Log10_32s_ISfs
// ipps10Log10_32s_Sfs
//
// Purpose: compute decimal logarithm multiplied by 10 of every elements
// of the source vector (for integer only).
//
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// Len length of the vector(s)
// ScaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector(s) is less or equal 0
// ippStsLnZeroArg zero value in the source vector
// ippStsLnNegArg negative value in the source vector
// ippStsNoErr otherwise
//
*/
IPPAPI(IppStatus, ipps10Log10_32s_ISfs,( Ipp32s* pSrcDst, int Len, int scaleFactor))
IPPAPI(IppStatus, ipps10Log10_32s_Sfs, ( const Ipp32s* pSrc, Ipp32s* pDst, int Len, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsSumLn
// Purpose: computes sum of natural logarithm every elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pSum pointer to the result
// len length of the vector
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector(s) is less or equal 0
// ippStsLnZeroArg zero value in the source vector
// ippStsLnNegArg negative value in the source vector
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsSumLn_32f,(const Ipp32f* pSrc, int len, Ipp32f* pSum))
IPPAPI(IppStatus, ippsSumLn_64f,(const Ipp64f* pSrc, int len, Ipp64f* pSum))
IPPAPI(IppStatus, ippsSumLn_32f64f,(const Ipp32f* pSrc, int len, Ipp64f* pSum))
IPPAPI(IppStatus, ippsSumLn_16s32f,(const Ipp16s* pSrc, int len, Ipp32f* pSum))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsSortAscend, ippsSortDescend
//
// Purpose: Execute sorting of all elemens of the vector.
// ippsSortAscend is sorted in increasing order.
// ippsSortDescend is sorted in decreasing order.
// Arguments:
// pSrcDst pointer to the source/destination vector
// len length of the vector
// Return:
// ippStsNullPtrErr pointer to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsSortAscend_8u_I, (Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortAscend_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortAscend_16u_I, (Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortAscend_32s_I, (Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortAscend_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortAscend_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_8u_I, (Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_16u_I, (Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_32s_I, (Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsSortDescend_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus,ippsSortIndexAscend_8u_I, (Ipp8u* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexAscend_16s_I,(Ipp16s* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexAscend_16u_I,(Ipp16u* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexAscend_32s_I,(Ipp32s* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexAscend_32f_I,(Ipp32f* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexAscend_64f_I,(Ipp64f* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_8u_I, (Ipp8u* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_16s_I,(Ipp16s* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_16u_I,(Ipp16u* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_32s_I,(Ipp32s* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_32f_I,(Ipp32f* pSrcDst, int* pDstIdx, int len ))
IPPAPI(IppStatus,ippsSortIndexDescend_64f_I,(Ipp64f* pSrcDst, int* pDstIdx, int len ))
/* /////////////////////////////////////////////////////////////////////////////////////
// Names: ippsSortRadixAscend, ippsSortRadixDescend
//
// Purpose: Rearrange elements of input vector using radix sort algorithm.
// ippsSortRadixAscend - sorts input array in increasing order
// ippsSortRadixDescend - sorts input array in decreasing order
//
// Arguments:
// pSrcDst pointer to the source/destination vector
// pTmp pointer to the temporary vector (same size as input one)
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the data or temporary placeholders is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsSortRadixAscend_32f_I, (Ipp32f *pSrcDst, Ipp32f *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_32s_I, (Ipp32s *pSrcDst, Ipp32s *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_32u_I, (Ipp32u *pSrcDst, Ipp32u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_16s_I, (Ipp16s *pSrcDst, Ipp16s *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_16u_I, (Ipp16u *pSrcDst, Ipp16u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_8u_I, (Ipp8u *pSrcDst, Ipp8u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixAscend_64f_I, (Ipp64f *pSrcDst, Ipp64f *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_32f_I, (Ipp32f *pSrcDst, Ipp32f *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_32s_I, (Ipp32s *pSrcDst, Ipp32s *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_32u_I, (Ipp32u *pSrcDst, Ipp32u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_16s_I, (Ipp16s *pSrcDst, Ipp16s *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_16u_I, (Ipp16u *pSrcDst, Ipp16u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_8u_I, (Ipp8u *pSrcDst, Ipp8u *pTmp, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixDescend_64f_I, (Ipp64f *pSrcDst, Ipp64f *pTmp, Ipp32s len))
/* /////////////////////////////////////////////////////////////////////////////////////
// Names: ippsSortRadixIndexAscend, ippsSortRadixIndexDescend
//
// Purpose: Indirectly sorts possibly sparse input vector, using indexes.
// For a dense input array the following will be true:
//
// ippsSortRadixIndexAscend - pSrc[pDstIndx[i-1]] <= pSrc[pDstIndx[i]];
// ippsSortRadixIndexDescend - pSrc[pDstIndx[i]] <= pSrc[pDstIndx[i-1]];
//
// Arguments:
// pSrc pointer to the first element of a sparse input vector;
// srcStrideBytes step between two consecutive elements of input vector in bytes;
// pDstIndx pointer to the output indexes vector;
// pTmpIndx pointer to the temporary indexes vector (same size as output one);
// len length of the vectors;
// Return:
// ippStsNullPtrErr pointer to the data or temporary placeholders is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsSortRadixIndexAscend_32f, (const Ipp32f * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexAscend_32s, (const Ipp32s * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexAscend_32u, (const Ipp32u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexAscend_16s, (const Ipp16s * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexAscend_16u, (const Ipp16u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexAscend_8u, (const Ipp8u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_32f, (const Ipp32f * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_32s, (const Ipp32s * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_32u, (const Ipp32u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_16s, (const Ipp16s * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_16u, (const Ipp16u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
IPPAPI(IppStatus, ippsSortRadixIndexDescend_8u, (const Ipp8u * const pSrc, Ipp32s srcStrideBytes,
Ipp32s *pDstIndx, Ipp32s *pTmpIndx, Ipp32s len))
/* /////////////////////////////////////////////////////////////////////////////
// Vector Measures Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsSum
// Purpose: sum all elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pSum pointer to the result
// len length of the vector
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the vector or result is NULL
// ippStsSizeErr length of the vector is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsSum_32f, (const Ipp32f* pSrc,int len, Ipp32f* pSum,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsSum_64f, (const Ipp64f* pSrc,int len, Ipp64f* pSum))
IPPAPI(IppStatus,ippsSum_32fc,(const Ipp32fc* pSrc,int len, Ipp32fc* pSum,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsSum_16s32s_Sfs, (const Ipp16s* pSrc, int len,
Ipp32s* pSum, int scaleFactor))
IPPAPI(IppStatus,ippsSum_16sc32sc_Sfs,(const Ipp16sc* pSrc, int len,
Ipp32sc* pSum, int scaleFactor))
IPPAPI(IppStatus,ippsSum_16s_Sfs, (const Ipp16s* pSrc, int len,
Ipp16s* pSum, int scaleFactor))
IPPAPI(IppStatus,ippsSum_16sc_Sfs, (const Ipp16sc* pSrc, int len,
Ipp16sc* pSum, int scaleFactor))
IPPAPI(IppStatus,ippsSum_32s_Sfs, (const Ipp32s* pSrc, int len,
Ipp32s* pSum, int scaleFactor))
IPPAPI(IppStatus,ippsSum_64fc,(const Ipp64fc* pSrc,int len, Ipp64fc* pSum))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMean
// Purpose: compute average value of all elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pMean pointer to the result
// len length of the source vector
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the vector or the result is NULL
// ippStsSizeErr length of the vector is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsMean_32f, (const Ipp32f* pSrc,int len,Ipp32f* pMean,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsMean_32fc,(const Ipp32fc* pSrc,int len,Ipp32fc* pMean,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsMean_64f, (const Ipp64f* pSrc,int len,Ipp64f* pMean))
IPPAPI(IppStatus,ippsMean_16s_Sfs, (const Ipp16s* pSrc,int len,
Ipp16s* pMean,int scaleFactor))
IPPAPI(IppStatus,ippsMean_16sc_Sfs,(const Ipp16sc* pSrc,int len,
Ipp16sc* pMean,int scaleFactor))
IPPAPI(IppStatus,ippsMean_64fc,(const Ipp64fc* pSrc,int len,Ipp64fc* pMean))
IPPAPI(IppStatus,ippsMean_32s_Sfs,(const Ipp32s *pSrc,int len,Ipp32s *pMean,
int scaleFactor ) )
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsStdDev
// Purpose: compute standard deviation value of all elements of the vector
// Parameters:
// pSrc pointer to the vector
// len length of the vector
// pStdDev pointer to the result
// scaleFactor scale factor value
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pointer to the vector or the result is NULL
// ippStsSizeErr length of the vector is less than 2
// Functionality:
// std = sqrt( sum( (x[n] - mean(x))^2, n=0..len-1 ) / (len-1) )
*/
IPPAPI(IppStatus,ippsStdDev_32f,(const Ipp32f* pSrc,int len,Ipp32f* pStdDev,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsStdDev_64f,(const Ipp64f* pSrc,int len,Ipp64f* pStdDev))
IPPAPI(IppStatus,ippsStdDev_16s32s_Sfs,(const Ipp16s* pSrc,int len,
Ipp32s* pStdDev,int scaleFactor))
IPPAPI(IppStatus,ippsStdDev_16s_Sfs,(const Ipp16s* pSrc,int len,
Ipp16s* pStdDev,int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMeanStdDev
// Purpose: compute standard deviation value and mean value
// of all elements of the vector
// Parameters:
// pSrc pointer to the vector
// len length of the vector
// pStdDev pointer to the result
// pMean pointer to the result
// scaleFactor scale factor value
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pointer to the vector or the result is NULL
// ippStsSizeErr length of the vector is less than 2
// Functionality:
// std = sqrt( sum( (x[n] - mean(x))^2, n=0..len-1 ) / (len-1) )
*/
IPPAPI(IppStatus,ippsMeanStdDev_32f,(const Ipp32f* pSrc, int len, Ipp32f* pMean, Ipp32f* pStdDev,
IppHintAlgorithm hint))
IPPAPI(IppStatus,ippsMeanStdDev_64f,(const Ipp64f* pSrc, int len, Ipp64f* pMean, Ipp64f* pStdDev))
IPPAPI(IppStatus,ippsMeanStdDev_16s32s_Sfs,(const Ipp16s* pSrc,int len, Ipp32s* pMean, Ipp32s* pStdDev,
int scaleFactor))
IPPAPI(IppStatus,ippsMeanStdDev_16s_Sfs,(const Ipp16s* pSrc,int len, Ipp16s* pMean, Ipp16s* pStdDev,
int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMax
// Purpose: find maximum value among all elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pMax pointer to the result
// len length of the vector
// Return:
// ippStsNullPtrErr pointer(s) to the vector or the result is NULL
// ippStsSizeErr length of the vector is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsMax_32f,(const Ipp32f* pSrc,int len,Ipp32f* pMax))
IPPAPI(IppStatus,ippsMax_64f,(const Ipp64f* pSrc,int len,Ipp64f* pMax))
IPPAPI(IppStatus,ippsMax_16s,(const Ipp16s* pSrc,int len,Ipp16s* pMax))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMaxIndx
//
// Purpose: find element with max value and return the value and the index
// Parameters:
// pSrc pointer to the input vector
// len length of the vector
// pMax address to place max value found
// pIndx address to place index found, may be NULL
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsMaxIndx_16s,
( const Ipp16s* pSrc, int len, Ipp16s* pMax, int* pIndx ))
IPPAPI ( IppStatus, ippsMaxIndx_32f,
( const Ipp32f* pSrc, int len, Ipp32f* pMax, int* pIndx ))
IPPAPI ( IppStatus, ippsMaxIndx_64f,
( const Ipp64f* pSrc, int len, Ipp64f* pMax, int* pIndx ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMin
// Purpose: find minimum value among all elements of the source vector
// Parameters:
// pSrc pointer to the source vector
// pMin pointer to the result
// len length of the vector
// Return:
// ippStsNullPtrErr pointer(s) to the vector or the result is NULL
// ippStsSizeErr length of the vector is less or equal 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus,ippsMin_32f,(const Ipp32f* pSrc,int len,Ipp32f* pMin))
IPPAPI(IppStatus,ippsMin_64f,(const Ipp64f* pSrc,int len,Ipp64f* pMin))
IPPAPI(IppStatus,ippsMin_16s,(const Ipp16s* pSrc,int len,Ipp16s* pMin))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsMinIndx
//
// Purpose: find element with min value and return the value and the index
// Parameters:
// pSrc pointer to the input vector
// len length of the vector
// pMin address to place min value found
// pIndx address to place index found, may be NULL
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsMinIndx_16s,
( const Ipp16s* pSrc, int len, Ipp16s* pMin, int* pIndx ))
IPPAPI ( IppStatus, ippsMinIndx_32f,
( const Ipp32f* pSrc, int len, Ipp32f* pMin, int* pIndx ))
IPPAPI ( IppStatus, ippsMinIndx_64f,
( const Ipp64f* pSrc, int len, Ipp64f* pMin, int* pIndx ))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsMinEvery, ippsMaxEvery
// Purpose: calculation min/max value for every element of two vectors
// Parameters:
// pSrc pointer to input vector
// pSrcDst pointer to input/output vector
// len vector's length
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr vector`s length is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsMinEvery_16s_I, (const Ipp16s* pSrc, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMinEvery_32s_I, (const Ipp32s* pSrc, Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMinEvery_32f_I, (const Ipp32f* pSrc, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMaxEvery_16s_I, (const Ipp16s* pSrc, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMaxEvery_32s_I, (const Ipp32s* pSrc, Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsMaxEvery_32f_I, (const Ipp32f* pSrc, Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsMinEvery_64f_I, (const Ipp64f* pSrc, Ipp64f* pSrcDst, Ipp32u len))
IPPAPI(IppStatus, ippsMaxEvery_8u_I, (const Ipp8u* pSrc, Ipp8u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsMinEvery_8u_I, (const Ipp8u* pSrc, Ipp8u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsMaxEvery_16u_I,(const Ipp16u* pSrc, Ipp16u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsMinEvery_16u_I,(const Ipp16u* pSrc, Ipp16u* pSrcDst, int len ))
IPPAPI(IppStatus, ippsMinMax_64f,(const Ipp64f* pSrc, int len, Ipp64f* pMin, Ipp64f* pMax))
IPPAPI(IppStatus, ippsMinMax_32f,(const Ipp32f* pSrc, int len, Ipp32f* pMin, Ipp32f* pMax))
IPPAPI(IppStatus, ippsMinMax_32s,(const Ipp32s* pSrc, int len, Ipp32s* pMin, Ipp32s* pMax))
IPPAPI(IppStatus, ippsMinMax_32u,(const Ipp32u* pSrc, int len, Ipp32u* pMin, Ipp32u* pMax))
IPPAPI(IppStatus, ippsMinMax_16s,(const Ipp16s* pSrc, int len, Ipp16s* pMin, Ipp16s* pMax))
IPPAPI(IppStatus, ippsMinMax_16u,(const Ipp16u* pSrc, int len, Ipp16u* pMin, Ipp16u* pMax))
IPPAPI(IppStatus, ippsMinMax_8u, (const Ipp8u* pSrc, int len, Ipp8u* pMin, Ipp8u* pMax))
IPPAPI(IppStatus, ippsMinMaxIndx_64f,(const Ipp64f* pSrc, int len, Ipp64f* pMin, int* pMinIndx,
Ipp64f* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_32f,(const Ipp32f* pSrc, int len, Ipp32f* pMin, int* pMinIndx,
Ipp32f* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_32s,(const Ipp32s* pSrc, int len, Ipp32s* pMin, int* pMinIndx,
Ipp32s* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_32u,(const Ipp32u* pSrc, int len, Ipp32u* pMin, int* pMinIndx,
Ipp32u* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_16s,(const Ipp16s* pSrc, int len, Ipp16s* pMin, int* pMinIndx,
Ipp16s* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_16u,(const Ipp16u* pSrc, int len, Ipp16u* pMin, int* pMinIndx,
Ipp16u* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMinMaxIndx_8u, (const Ipp8u* pSrc, int len, Ipp8u* pMin, int* pMinIndx,
Ipp8u* pMax, int* pMaxIndx))
IPPAPI(IppStatus, ippsMin_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMin))
IPPAPI(IppStatus, ippsMax_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMax))
IPPAPI(IppStatus, ippsMinIndx_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMin, int* pIndx))
IPPAPI(IppStatus, ippsMaxIndx_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMax, int* pIndx))
IPPAPI(IppStatus, ippsMinAbs_16s, (const Ipp16s* pSrc, int len, Ipp16s* pMinAbs))
IPPAPI(IppStatus, ippsMaxAbs_16s, (const Ipp16s* pSrc, int len, Ipp16s* pMaxAbs))
IPPAPI(IppStatus, ippsMinAbsIndx_16s, (const Ipp16s* pSrc, int len, Ipp16s* pMinAbs, int* pIndx))
IPPAPI(IppStatus, ippsMaxAbsIndx_16s, (const Ipp16s* pSrc, int len, Ipp16s* pMaxAbs, int* pIndx))
IPPAPI(IppStatus, ippsMinAbs_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMinAbs))
IPPAPI(IppStatus, ippsMaxAbs_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMaxAbs))
IPPAPI(IppStatus, ippsMinAbsIndx_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMinAbs, int* pIndx))
IPPAPI(IppStatus, ippsMaxAbsIndx_32s, (const Ipp32s* pSrc, int len, Ipp32s* pMaxAbs, int* pIndx))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPhase_64fc
// ippsPhase_32fc
// ippsPhase_16sc_Sfs
// ippsPhase_16sc32f
// Purpose:
// Compute the phase (in radians) of complex vector elements.
// Parameters:
// pSrcRe - an input complex vector
// pDst - an output vector to store the phase components;
// len - a length of the arrays.
// scaleFactor - a scale factor of output results (only for integer data)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsBadSizeErr The length of the arrays is less or equal zero
*/
IPPAPI(IppStatus, ippsPhase_64fc,(const Ipp64fc* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsPhase_32fc,(const Ipp32fc* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsPhase_16sc32f,(const Ipp16sc* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsPhase_16sc_Sfs,(const Ipp16sc* pSrc, Ipp16s* pDst, int len,
int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPhase_64f
// ippsPhase_32f
// ippsPhase_16s_Sfs
// ippsPhase_16s32f
// Purpose:
// Compute the phase of complex data formed as two real vectors.
// Parameters:
// pSrcRe - an input vector containing a real part of complex data
// pSrcIm - an input vector containing an imaginary part of complex data
// pDst - an output vector to store the phase components
// len - a length of the arrays.
// scaleFactor - a scale factor of output results (only for integer data)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsBadSizeErr The length of the arrays is less or equal zero
*/
IPPAPI(IppStatus, ippsPhase_64f,(const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsPhase_32f,(const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsPhase_16s_Sfs,(const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsPhase_16s32f,(const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp32f* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPhase_32sc_Sfs
// Purpose:
// Compute the phase (in radians) of complex vector elements.
// Parameters:
// pSrcRe - an input complex vector
// pDst - an output vector to store the phase components;
// len - a length of the arrays.
// scaleFactor - a scale factor of output results (only for integer data)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsBadSizeErr The length of the arrays is less or equal zero
*/
IPPAPI(IppStatus, ippsPhase_32sc_Sfs,(const Ipp32sc* pSrc, Ipp32s* pDst, int len,
int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsMaxOrder_64f
// ippsMaxOrder_32f
// ippsMaxOrder_32s
// ippsMaxOrder_16s
// Purpose:
// Determines the maximal number of binary digits for data representation.
// Parameters:
// pSrc The pointer on input signal vector.
// pOrder Pointer to result value.
// len The length of the input vector.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
// ippStsNanArg If not a number is met in a input value
*/
IPPAPI(IppStatus, ippsMaxOrder_64f,(const Ipp64f* pSrc, int len, int* pOrder))
IPPAPI(IppStatus, ippsMaxOrder_32f,(const Ipp32f* pSrc, int len, int* pOrder))
IPPAPI(IppStatus, ippsMaxOrder_32s,(const Ipp32s* pSrc, int len, int* pOrder))
IPPAPI(IppStatus, ippsMaxOrder_16s,(const Ipp16s* pSrc, int len, int* pOrder))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsArctan
//
// Purpose: compute arctangent value for all elements of the source vector
//
// Return:
// stsNoErr Ok
// stsNullPtrErr Some of pointers to input or output data are NULL
// stsBadSizeErr The length of the arrays is less or equal zero
//
// Parameters:
// pSrcDst pointer to the source/destination vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len a length of the array
//
*/
IPPAPI(IppStatus, ippsArctan_32f_I,( Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsArctan_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsArctan_64f_I,( Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsArctan_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFindNearestOne
// Purpose: Searches the table for an element closest to the reference value
// and returns its value and index
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr At least one of the specified pointers is NULL
// ippStsSizeErr The length of the table is less than or equal to zero
// Parameters:
// inpVal reference Value
// pOutVal pointer to the found value
// pOutIndx pointer to the found index
// pTable table for search
// tblLen length of the table
// Notes:
// The table should contain monotonically increasing values
*/
IPPAPI(IppStatus, ippsFindNearestOne_16u, (Ipp16u inpVal, Ipp16u* pOutVal, int* pOutIndex, const Ipp16u *pTable, int tblLen))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFindNearest
// Purpose: Searches the table for elements closest to the reference values
// and the their indexes
// Context:
// Returns: IppStatus
// ippStsNoErr Ok
// ippStsNullPtrErr At least one of the specified pointers is NULL
// ippStsSizeErr The length of table or pVals is less than or equal to zero
// Parameters:
// pVals pointer to the reference values vector
// pOutVals pointer to the vector with the found values
// pOutIndexes pointer to the array with indexes of the found elements
// len length of the input vector
// pTable table for search
// tblLen length of the table
// Notes:
// The table should contain monotonically increasing values
*/
IPPAPI(IppStatus, ippsFindNearest_16u, (const Ipp16u* pVals, Ipp16u* pOutVals, int* pOutIndexes, int len, const Ipp16u *pTable, int tblLen))
/* /////////////////////////////////////////////////////////////////////////////
// Vector logical functions
///////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsAnd, ippsOr, ippsXor, ippsNot, ippsLShiftC, ippsRShiftC
// Purpose: logical operations and vector shifts
// Parameters:
// val 1) value to be ANDed/ORed/XORed with each element of the vector (And, Or, Xor);
// 2) position`s number which vector elements to be SHIFTed on (ShiftC)
// pSrc pointer to input vector
// pSrcDst pointer to input/output vector
// pSrc1 pointer to first input vector
// pSrc2 pointer to second input vector
// pDst pointer to output vector
// len vector's length
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr vector`s length is less or equal zero
// ippStsShiftErr shift`s value is less zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsAndC_8u_I, (Ipp8u val, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAndC_8u, (const Ipp8u* pSrc, Ipp8u val, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsAndC_16u_I, (Ipp16u val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAndC_16u, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsAndC_32u_I, (Ipp32u val, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAndC_32u, (const Ipp32u* pSrc, Ipp32u val, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsAnd_8u_I, (const Ipp8u* pSrc, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAnd_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsAnd_16u_I, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAnd_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsAnd_32u_I, (const Ipp32u* pSrc, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsAnd_32u, (const Ipp32u* pSrc1, const Ipp32u* pSrc2, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsOrC_8u_I, (Ipp8u val, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOrC_8u, (const Ipp8u* pSrc, Ipp8u val, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsOrC_16u_I, (Ipp16u val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOrC_16u, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsOrC_32u_I, (Ipp32u val, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOrC_32u, (const Ipp32u* pSrc, Ipp32u val, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsOr_8u_I, (const Ipp8u* pSrc, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOr_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsOr_16u_I, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOr_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsOr_32u_I, (const Ipp32u* pSrc, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsOr_32u, (const Ipp32u* pSrc1, const Ipp32u* pSrc2, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsXorC_8u_I, (Ipp8u val, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXorC_8u, (const Ipp8u* pSrc, Ipp8u val, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsXorC_16u_I, (Ipp16u val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXorC_16u, (const Ipp16u* pSrc, Ipp16u val, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsXorC_32u_I, (Ipp32u val, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXorC_32u, (const Ipp32u* pSrc, Ipp32u val, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsXor_8u_I, (const Ipp8u* pSrc, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXor_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsXor_16u_I, (const Ipp16u* pSrc, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXor_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsXor_32u_I, (const Ipp32u* pSrc, Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsXor_32u, (const Ipp32u* pSrc1, const Ipp32u* pSrc2, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsNot_8u_I, (Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsNot_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsNot_16u_I, (Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsNot_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsNot_32u_I, (Ipp32u* pSrcDst, int len))
IPPAPI(IppStatus, ippsNot_32u, (const Ipp32u* pSrc, Ipp32u* pDst, int len))
IPPAPI(IppStatus, ippsLShiftC_8u_I, (int val, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsLShiftC_8u, (const Ipp8u* pSrc, int val, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsLShiftC_16u_I, (int val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsLShiftC_16u, (const Ipp16u* pSrc, int val, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsLShiftC_16s_I, (int val, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsLShiftC_16s, (const Ipp16s* pSrc, int val, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsLShiftC_32s_I, (int val, Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsLShiftC_32s, (const Ipp32s* pSrc, int val, Ipp32s* pDst, int len))
IPPAPI(IppStatus, ippsRShiftC_8u_I, (int val, Ipp8u* pSrcDst, int len))
IPPAPI(IppStatus, ippsRShiftC_8u, (const Ipp8u* pSrc, int val, Ipp8u* pDst, int len))
IPPAPI(IppStatus, ippsRShiftC_16u_I, (int val, Ipp16u* pSrcDst, int len))
IPPAPI(IppStatus, ippsRShiftC_16u, (const Ipp16u* pSrc, int val, Ipp16u* pDst, int len))
IPPAPI(IppStatus, ippsRShiftC_16s_I, (int val, Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsRShiftC_16s, (const Ipp16s* pSrc, int val, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsRShiftC_32s_I, (int val, Ipp32s* pSrcDst, int len))
IPPAPI(IppStatus, ippsRShiftC_32s, (const Ipp32s* pSrc, int val, Ipp32s* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Dot Product Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDotProd
// Purpose: compute Dot Product value
// Arguments:
// pSrc1 pointer to the source vector
// pSrc2 pointer to the another source vector
// len vector's length, number of items
// pDp pointer to the result
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer(s) pSrc pDst is NULL
// ippStsSizeErr length of the vectors is less or equal 0
// ippStsNoErr otherwise
// Notes:
// the functions don't conjugate one of the source vectors
*/
IPPAPI(IppStatus, ippsDotProd_32f, (const Ipp32f* pSrc1,
const Ipp32f* pSrc2, int len, Ipp32f* pDp))
IPPAPI(IppStatus, ippsDotProd_32fc,(const Ipp32fc* pSrc1,
const Ipp32fc* pSrc2, int len, Ipp32fc* pDp))
IPPAPI(IppStatus, ippsDotProd_32f32fc,(const Ipp32f* pSrc1,
const Ipp32fc* pSrc2, int len, Ipp32fc* pDp))
IPPAPI(IppStatus, ippsDotProd_64f, (const Ipp64f* pSrc1,
const Ipp64f* pSrc2, int len, Ipp64f* pDp))
IPPAPI(IppStatus, ippsDotProd_64fc,(const Ipp64fc* pSrc1,
const Ipp64fc* pSrc2, int len, Ipp64fc* pDp))
IPPAPI(IppStatus, ippsDotProd_64f64fc,(const Ipp64f* pSrc1,
const Ipp64fc* pSrc2, int len, Ipp64fc* pDp))
IPPAPI(IppStatus, ippsDotProd_16s_Sfs, (const Ipp16s* pSrc1,
const Ipp16s* pSrc2, int len, Ipp16s* pDp, int scaleFactor))
IPPAPI(IppStatus, ippsDotProd_16sc_Sfs,(const Ipp16sc* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp16sc* pDp, int scaleFactor))
IPPAPI(IppStatus, ippsDotProd_16s16sc_Sfs, (const Ipp16s* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp16sc* pDp, int scaleFactor))
IPPAPI(IppStatus, ippsDotProd_16s64s, (const Ipp16s* pSrc1,
const Ipp16s* pSrc2, int len, Ipp64s* pDp))
IPPAPI(IppStatus, ippsDotProd_16sc64sc, (const Ipp16sc* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp64sc* pDp))
IPPAPI(IppStatus, ippsDotProd_16s16sc64sc,(const Ipp16s* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp64sc* pDp))
IPPAPI(IppStatus, ippsDotProd_16s32f, (const Ipp16s* pSrc1,
const Ipp16s* pSrc2, int len, Ipp32f* pDp))
IPPAPI(IppStatus, ippsDotProd_16sc32fc, (const Ipp16sc* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp32fc* pDp))
IPPAPI(IppStatus, ippsDotProd_16s16sc32fc,(const Ipp16s* pSrc1,
const Ipp16sc* pSrc2, int len, Ipp32fc* pDp))
IPPAPI ( IppStatus, ippsDotProd_32f64f,
( const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp64f* pDp ))
IPPAPI ( IppStatus, ippsDotProd_32fc64fc,
( const Ipp32fc* pSrc1, const Ipp32fc* pSrc2, int len, Ipp64fc* pDp ))
IPPAPI ( IppStatus, ippsDotProd_32f32fc64fc,
( const Ipp32f* pSrc1, const Ipp32fc* pSrc2, int len, Ipp64fc* pDp ))
IPPAPI ( IppStatus, ippsDotProd_16s32s_Sfs,
( const Ipp16s* pSrc1, const Ipp16s* pSrc2,
int len, Ipp32s* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_16sc32sc_Sfs,
( const Ipp16sc* pSrc1, const Ipp16sc* pSrc2,
int len, Ipp32sc* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_16s16sc32sc_Sfs,
( const Ipp16s* pSrc1, const Ipp16sc* pSrc2,
int len, Ipp32sc* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_32s_Sfs,
( const Ipp32s* pSrc1, const Ipp32s* pSrc2,
int len, Ipp32s* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_32sc_Sfs,
( const Ipp32sc* pSrc1, const Ipp32sc* pSrc2,
int len, Ipp32sc* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_32s32sc_Sfs,
( const Ipp32s* pSrc1, const Ipp32sc* pSrc2,
int len, Ipp32sc* pDp, int scaleFactor ))
IPPAPI ( IppStatus, ippsDotProd_16s32s32s_Sfs,
( const Ipp16s* pSrc1, const Ipp32s* pSrc2,
int len, Ipp32s* pDp, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPowerSpectr_64fc
// ippsPowerSpectr_32fc
// ippsPowerSpectr_16sc_Sfs
// ippsPowerSpectr_16sc32f
// Purpose:
// Compute the power spectrum of complex vector
// Parameters:
// pSrcRe - pointer to the real part of input vector.
// pSrcIm - pointer to the image part of input vector.
// pDst - pointer to the result.
// len - vector length.
// scaleFactor - scale factor for rezult (only for integer data).
// Return:
// ippStsNullPtrErr indicates that one or more pointers to the data is NULL.
// ippStsSizeErr indicates that vector length is less or equal zero.
// ippStsNoErr otherwise.
*/
IPPAPI(IppStatus, ippsPowerSpectr_64fc,(const Ipp64fc* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsPowerSpectr_32fc,(const Ipp32fc* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsPowerSpectr_16sc_Sfs,(const Ipp16sc* pSrc, Ipp16s* pDst,
int len, int scaleFactor))
IPPAPI(IppStatus, ippsPowerSpectr_16sc32f, (const Ipp16sc* pSrc, Ipp32f* pDst,
int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsPowerSpectr_64f
// ippsPowerSpectr_32f
// ippsPowerSpectr_16s_Sfs
// ippsPowerSpectr_16s32f
// Purpose:
// Compute the power spectrum of complex data formed as two real vectors
// Parameters:
// pSrcRe - pointer to the real part of input vector.
// pSrcIm - pointer to the image part of input vector.
// pDst - pointer to the result.
// len - vector length.
// scaleFactor - scale factor for rezult (only for integer data).
// Return:
// ippStsNullPtrErr indicates that one or more pointers to the data is NULL.
// ippStsSizeErr indicates that vector length is less or equal zero.
// ippStsNoErr otherwise.
*/
IPPAPI(IppStatus, ippsPowerSpectr_64f,(const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsPowerSpectr_32f,(const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsPowerSpectr_16s_Sfs,(const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDst, int len, int scaleFactor))
IPPAPI(IppStatus, ippsPowerSpectr_16s32f, (const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp32f* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Linear Transform
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsNormalize_64fc
// ippsNormalize_32fc
// ippsNormalize_16sc_Sfs
// Purpose:
// Complex vector normalization using offset and division method.
// Parameters:
// pSrc - an input complex vector
// pDst - an output complex vector
// len - a length of the arrays.
// vsub - complex a subtrahend
// vdiv - denominator
// scaleFactor - a scale factor of output results (only for integer data)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
// ippStsDivByZeroErr denominator equal zero or less than float
// format minimum
*/
IPPAPI(IppStatus, ippsNormalize_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst,
int len, Ipp64fc vsub, Ipp64f vdiv))
IPPAPI(IppStatus, ippsNormalize_32fc,(const Ipp32fc* pSrc, Ipp32fc* pDst,
int len, Ipp32fc vsub, Ipp32f vdiv))
IPPAPI(IppStatus, ippsNormalize_16sc_Sfs,(const Ipp16sc* pSrc, Ipp16sc* pDst,
int len, Ipp16sc vsub, int vdiv, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippsNormalize_64f
// ippsNormalize_32f
// ippsNormalize_16s_Sfs
// Purpose:
// Normalize elements of real vector with the help of offset and division.
// Parameters:
// pSrc - an input vector of real data
// pDst - an output vector of real data
// len - a length of the arrays.
// vsub - subtrahend
// vdiv - denominator
// scaleFactor - a scale factor of output results (only for integer data)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of the arrays is less or equal zero
// ippStsDivByZeroErr denominator equal zero or less than float
// format minimum
*/
IPPAPI(IppStatus, ippsNormalize_64f,(const Ipp64f* pSrc, Ipp64f* pDst, int len,
Ipp64f vsub, Ipp64f vdiv))
IPPAPI(IppStatus, ippsNormalize_32f,(const Ipp32f* pSrc, Ipp32f* pDst, int len,
Ipp32f vsub, Ipp32f vdiv))
IPPAPI(IppStatus, ippsNormalize_16s_Sfs,(const Ipp16s* pSrc, Ipp16s* pDst,
int len, Ipp16s vsub, int vdiv, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Definitions for FFT Functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct FFTSpec_C_32fc IppsFFTSpec_C_32fc;
typedef struct FFTSpec_C_32f IppsFFTSpec_C_32f;
typedef struct FFTSpec_R_32f IppsFFTSpec_R_32f;
typedef struct FFTSpec_C_64fc IppsFFTSpec_C_64fc;
typedef struct FFTSpec_C_64f IppsFFTSpec_C_64f;
typedef struct FFTSpec_R_64f IppsFFTSpec_R_64f;
typedef struct FFTSpec_C_16sc IppsFFTSpec_C_16sc;
typedef struct FFTSpec_C_16s IppsFFTSpec_C_16s;
typedef struct FFTSpec_R_16s IppsFFTSpec_R_16s;
typedef struct FFTSpec_C_32sc IppsFFTSpec_C_32sc;
typedef struct FFTSpec_C_32s IppsFFTSpec_C_32s;
typedef struct FFTSpec_R_32s IppsFFTSpec_R_32s;
typedef struct FFTSpec_R_16s32s IppsFFTSpec_R_16s32s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// FFT Get Size Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTGetSize_C, ippsFFTGetSize_R
// Purpose: get sizes of the FFTSpec and buffers (on bytes)
// Arguments:
// order - base-2 logarithm of the number of samples in FFT
// flag - normalization flag
// hint - code specific use hints
// pSpecSize - where write size of FFTSpec
// pSpecBufferSize - where write size of buffer for FFTInit functions
// pBufferSize - where write size of buffer for FFT calculation
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSpecSize == NULL or pSpecBufferSize == NULL or
// pBufferSize == NULL
// ippStsFftOrderErr bad the order value
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI (IppStatus, ippsFFTGetSize_C_32fc,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_32f,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_R_32f,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_64fc,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_64f,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_R_64f,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_16sc,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_16s,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_R_16s,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_32sc,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_C_32s,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_R_32s,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetSize_R_16s32s,
( int order, int flag, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
/* /////////////////////////////////////////////////////////////////////////////
// FFT Context Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTInit_C, ippsFFTInit_R
// Purpose: initialize of FFT context
// Arguments:
// order - base-2 logarithm of the number of samples in FFT
// flag - normalization flag
// hint - code specific use hints
// ppFFTSpec - where write pointer to new context
// pSpec - pointer to area for FFTSpec
// pSpecBuffer - pointer to work buffer
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr ppFFTSpec == NULL or
// pSpec == NULL or pSpecBuffer == NULL
// ippStsFftOrderErr bad the order value
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI (IppStatus, ippsFFTInit_C_32fc,
( IppsFFTSpec_C_32fc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_32f,
( IppsFFTSpec_C_32f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_R_32f,
( IppsFFTSpec_R_32f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_64fc,
( IppsFFTSpec_C_64fc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_64f,
( IppsFFTSpec_C_64f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_R_64f,
( IppsFFTSpec_R_64f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_16sc,
( IppsFFTSpec_C_16sc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_16s,
( IppsFFTSpec_C_16s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_R_16s,
( IppsFFTSpec_R_16s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_32sc,
( IppsFFTSpec_C_32sc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_C_32s,
( IppsFFTSpec_C_32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_R_32s,
( IppsFFTSpec_R_32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsFFTInit_R_16s32s,
( IppsFFTSpec_R_16s32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTInitAlloc_C, ippsFFTInitAlloc_R
// Purpose: create and initialize of FFT context
// Arguments:
// order - base-2 logarithm of the number of samples in FFT
// flag - normalization flag
// hint - code specific use hints
// ppFFTSpec - where write pointer to new context
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr ppFFTSpec == NULL
// ippStsFftOrderErr bad the order value
// ippStsFftFlagErr bad the normalization flag value
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32fc,
( IppsFFTSpec_C_32fc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32f,
( IppsFFTSpec_C_32f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_R_32f,
( IppsFFTSpec_R_32f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_64fc,
( IppsFFTSpec_C_64fc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_64f,
( IppsFFTSpec_C_64f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_R_64f,
( IppsFFTSpec_R_64f** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_16sc,
( IppsFFTSpec_C_16sc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_16s,
( IppsFFTSpec_C_16s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_R_16s,
( IppsFFTSpec_R_16s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32sc,
( IppsFFTSpec_C_32sc** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32s,
( IppsFFTSpec_C_32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_R_32s,
( IppsFFTSpec_R_32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsFFTInitAlloc_R_16s32s,
( IppsFFTSpec_R_16s32s** ppFFTSpec,
int order, int flag, IppHintAlgorithm hint ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTFree_C, ippsFFTFree_R
// Purpose: delete FFT context
// Arguments:
// pFFTSpec - pointer to FFT context to be deleted
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pFFTSpec == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsFFTFree_C_32fc, ( IppsFFTSpec_C_32fc* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_32f, ( IppsFFTSpec_C_32f* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_R_32f, ( IppsFFTSpec_R_32f* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_64fc, ( IppsFFTSpec_C_64fc* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_64f, ( IppsFFTSpec_C_64f* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_R_64f, ( IppsFFTSpec_R_64f* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_16sc, ( IppsFFTSpec_C_16sc* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_16s, ( IppsFFTSpec_C_16s* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_R_16s, ( IppsFFTSpec_R_16s* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_32sc, ( IppsFFTSpec_C_32sc* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_C_32s, ( IppsFFTSpec_C_32s* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_R_32s, ( IppsFFTSpec_R_32s* pFFTSpec ))
IPPAPI (IppStatus, ippsFFTFree_R_16s32s, ( IppsFFTSpec_R_16s32s* pFFTSpec ))
/* /////////////////////////////////////////////////////////////////////////////
// FFT Buffer Size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTGetBufSize_C, ippsFFTGetBufSize_R
// Purpose: get size of the FFT work buffer (on bytes)
// Arguments:
// pFFTSpec - pointer to the FFT structure
// pBufferSize - Pointer to the FFT work buffer size value
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pFFTSpec == NULL or pBufferSize == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32fc,
( const IppsFFTSpec_C_32fc* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32f,
( const IppsFFTSpec_C_32f* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_R_32f,
( const IppsFFTSpec_R_32f* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_64fc,
( const IppsFFTSpec_C_64fc* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_64f,
( const IppsFFTSpec_C_64f* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_R_64f,
( const IppsFFTSpec_R_64f* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_16sc,
( const IppsFFTSpec_C_16sc* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_16s,
( const IppsFFTSpec_C_16s* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_R_16s,
( const IppsFFTSpec_R_16s* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32sc,
( const IppsFFTSpec_C_32sc* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32s,
( const IppsFFTSpec_C_32s* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_R_32s,
( const IppsFFTSpec_R_32s* pFFTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsFFTGetBufSize_R_16s32s,
( const IppsFFTSpec_R_16s32s* pFFTSpec, int* pBufferSize ))
/* /////////////////////////////////////////////////////////////////////////////
// FFT Complex Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTFwd_CToC, ippsFFTInv_CToC
// Purpose: compute forward and inverse FFT of the complex signal
// Arguments:
// pFFTSpec - pointer to FFT context
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// pSrcRe - pointer to real part of source signal
// pSrcIm - pointer to imaginary part of source signal
// pDstRe - pointer to real part of destination signal
// pDstIm - pointer to imaginary part of destination signal
// pSrcDSt - pointer to complex signal
// pSrcDstRe- pointer to real part of signal
// pSrcDstIm- pointer to imaginary part of signal
// pBuffer - pointer to work buffer
// scaleFactor
// - scale factor for output result
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pFFTSpec == NULL or
// pSrc == NULL or pDst == NULL or
// pSrcRe == NULL or pSrcIm == NULL or
// pDstRe == NULL or pDstIm == NULL or
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsFFTFwd_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsFFTSpec_C_32fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsFFTSpec_C_32fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32f,
( const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDstRe, Ipp32f* pDstIm,
const IppsFFTSpec_C_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32f,
( const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDstRe, Ipp32f* pDstIm,
const IppsFFTSpec_C_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32fc_I,
( Ipp32fc* pSrcDst,
const IppsFFTSpec_C_32fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32fc_I,
( Ipp32fc* pSrcDst,
const IppsFFTSpec_C_32fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32f_I,
( Ipp32f* pSrcDstRe, Ipp32f* pSrcDstIm,
const IppsFFTSpec_C_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32f_I,
( Ipp32f* pSrcDstRe, Ipp32f* pSrcDstIm,
const IppsFFTSpec_C_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsFFTSpec_C_64fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsFFTSpec_C_64fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_64f,
( const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDstRe, Ipp64f* pDstIm,
const IppsFFTSpec_C_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_64f,
( const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDstRe, Ipp64f* pDstIm,
const IppsFFTSpec_C_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_64fc_I,
( Ipp64fc* pSrcDst,
const IppsFFTSpec_C_64fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_64fc_I,
( Ipp64fc* pSrcDst,
const IppsFFTSpec_C_64fc* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_64f_I,
( Ipp64f* pSrcDstRe, Ipp64f* pSrcDstIm,
const IppsFFTSpec_C_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_64f_I,
( Ipp64f* pSrcDstRe, Ipp64f* pSrcDstIm,
const IppsFFTSpec_C_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_16sc_Sfs,
( const Ipp16sc* pSrc, Ipp16sc* pDst,
const IppsFFTSpec_C_16sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_16sc_Sfs,
( const Ipp16sc* pSrc, Ipp16sc* pDst,
const IppsFFTSpec_C_16sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_16s_Sfs,
( const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDstRe, Ipp16s* pDstIm,
const IppsFFTSpec_C_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_16s_Sfs,
( const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDstRe, Ipp16s* pDstIm,
const IppsFFTSpec_C_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_16sc_ISfs,
( Ipp16sc* pSrcDst,
const IppsFFTSpec_C_16sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_16sc_ISfs,
( Ipp16sc* pSrcDst,
const IppsFFTSpec_C_16sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_16s_ISfs,
( Ipp16s* pSrcDstRe, Ipp16s* pSrcDstIm,
const IppsFFTSpec_C_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_16s_ISfs,
( Ipp16s* pSrcDstRe, Ipp16s* pSrcDstIm,
const IppsFFTSpec_C_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32sc_Sfs,
( const Ipp32sc* pSrc, Ipp32sc* pDst,
const IppsFFTSpec_C_32sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32sc_Sfs,
( const Ipp32sc* pSrc, Ipp32sc* pDst,
const IppsFFTSpec_C_32sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32s_Sfs,
( const Ipp32s* pSrcRe, const Ipp32s* pSrcIm,
Ipp32s* pDstRe, Ipp32s* pDstIm,
const IppsFFTSpec_C_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32s_Sfs,
( const Ipp32s* pSrcRe, const Ipp32s* pSrcIm,
Ipp32s* pDstRe, Ipp32s* pDstIm,
const IppsFFTSpec_C_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32sc_ISfs,
( Ipp32sc* pSrcDst,
const IppsFFTSpec_C_32sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32sc_ISfs,
( Ipp32sc* pSrcDst,
const IppsFFTSpec_C_32sc* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_CToC_32s_ISfs,
( Ipp32s* pSrcDstRe, Ipp32s* pSrcDstIm,
const IppsFFTSpec_C_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CToC_32s_ISfs,
( Ipp32s* pSrcDstRe, Ipp32s* pSrcDstIm,
const IppsFFTSpec_C_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// FFT Real Packed Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFFTFwd_RToPerm, ippsFFTFwd_RToPack, ippsFFTFwd_RToCCS
// ippsFFTInv_PermToR, ippsFFTInv_PackToR, ippsFFTInv_CCSToR
// Purpose: compute forward and inverse FFT of real signal
// using Perm, Pack or Ccs packed format
// Arguments:
// pFFTSpec - pointer to FFT context
// pSrc - pointer to source signal
// pDst - pointer to destination signal
// pSrcDst - pointer to signal
// pBuffer - pointer to work buffer
// scaleFactor
// - scale factor for output result
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pFFTSpec == NULL or
// pSrc == NULL or pDst == NULL
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32f_I,
( Ipp32f* pSrcDst,
const IppsFFTSpec_R_32f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_64f_I,
( Ipp64f* pSrcDst,
const IppsFFTSpec_R_64f* pFFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsFFTSpec_R_16s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32s_Sfs,
( const Ipp32s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PermToR_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_PackToR_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32s_ISfs,
( Ipp32s* pSrcDst,
const IppsFFTSpec_R_32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s32s_Sfs,
( const Ipp16s* pSrc, Ipp32s* pDst,
const IppsFFTSpec_R_16s32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32s16s_Sfs,
( const Ipp32s* pSrc, Ipp16s* pDst,
const IppsFFTSpec_R_16s32s* pFFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Definitions for DFT Functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct DFTSpec_C_16sc IppsDFTSpec_C_16sc;
typedef struct DFTSpec_C_16s IppsDFTSpec_C_16s;
typedef struct DFTSpec_R_16s IppsDFTSpec_R_16s;
typedef struct DFTSpec_C_32fc IppsDFTSpec_C_32fc;
typedef struct DFTSpec_C_32f IppsDFTSpec_C_32f;
typedef struct DFTSpec_R_32f IppsDFTSpec_R_32f;
typedef struct DFTSpec_C_64fc IppsDFTSpec_C_64fc;
typedef struct DFTSpec_C_64f IppsDFTSpec_C_64f;
typedef struct DFTSpec_R_64f IppsDFTSpec_R_64f;
typedef struct DFTOutOrdSpec_C_32fc IppsDFTOutOrdSpec_C_32fc;
typedef struct DFTOutOrdSpec_C_64fc IppsDFTOutOrdSpec_C_64fc;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// DFT Context Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDFTInitAlloc_C, ippsDFTInitAlloc_R
// Purpose: create and initialize of DFT context
// Arguments:
// length - number of samples in DFT
// flag - normalization flag
// hint - code specific use hints
// pDFTSpec - where write pointer to new context
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDFTSpec == NULL
// ippStsSizeErr bad the length value
// ippStsFFTFlagErr bad the normalization flag value
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsDFTInitAlloc_C_16sc,
( IppsDFTSpec_C_16sc** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_C_16s,
( IppsDFTSpec_C_16s** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_R_16s,
( IppsDFTSpec_R_16s** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_C_32fc,
( IppsDFTSpec_C_32fc** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_C_32f,
( IppsDFTSpec_C_32f** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_R_32f,
( IppsDFTSpec_R_32f** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_C_64fc,
( IppsDFTSpec_C_64fc** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_C_64f,
( IppsDFTSpec_C_64f** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTInitAlloc_R_64f,
( IppsDFTSpec_R_64f** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTOutOrdInitAlloc_C_32fc,
( IppsDFTOutOrdSpec_C_32fc** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDFTOutOrdInitAlloc_C_64fc,
( IppsDFTOutOrdSpec_C_64fc** pDFTSpec,
int length, int flag, IppHintAlgorithm hint ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDFTFree_C, ippsDFTFree_R
// Purpose: delete DFT context
// Arguments:
// pDFTSpec - pointer to DFT context to be deleted
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDFTSpec == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsDFTFree_C_16sc, ( IppsDFTSpec_C_16sc* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_C_16s, ( IppsDFTSpec_C_16s* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_R_16s, ( IppsDFTSpec_R_16s* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_C_32fc, ( IppsDFTSpec_C_32fc* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_C_32f, ( IppsDFTSpec_C_32f* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_R_32f, ( IppsDFTSpec_R_32f* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_C_64fc, ( IppsDFTSpec_C_64fc* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_C_64f, ( IppsDFTSpec_C_64f* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTFree_R_64f, ( IppsDFTSpec_R_64f* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTOutOrdFree_C_32fc, ( IppsDFTOutOrdSpec_C_32fc* pDFTSpec ))
IPPAPI (IppStatus, ippsDFTOutOrdFree_C_64fc, ( IppsDFTOutOrdSpec_C_64fc* pDFTSpec ))
/* /////////////////////////////////////////////////////////////////////////////
// DFT Buffer Size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDFTGetBufSize_C, ippsDFTGetBufSize_R
// Purpose: get size of the DFT work buffer (on bytes)
// Arguments:
// pDFTSpec - pointer to DFT context
// pSize - where write size of buffer
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDFTSpec == NULL or pSize == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsDFTGetBufSize_C_16sc,
( const IppsDFTSpec_C_16sc* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_C_16s,
( const IppsDFTSpec_C_16s* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_R_16s,
( const IppsDFTSpec_R_16s* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_C_32fc,
( const IppsDFTSpec_C_32fc* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_C_32f,
( const IppsDFTSpec_C_32f* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_R_32f,
( const IppsDFTSpec_R_32f* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_C_64fc,
( const IppsDFTSpec_C_64fc* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_C_64f,
( const IppsDFTSpec_C_64f* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTGetBufSize_R_64f,
( const IppsDFTSpec_R_64f* pDFTSpec, int* pSize ))
IPPAPI (IppStatus, ippsDFTOutOrdGetBufSize_C_32fc,
( const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, int* size ))
IPPAPI (IppStatus, ippsDFTOutOrdGetBufSize_C_64fc,
( const IppsDFTOutOrdSpec_C_64fc* pDFTSpec, int* size ))
/* /////////////////////////////////////////////////////////////////////////////
// DFT Complex Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDFTFwd_CToC, ippsDFTInv_CToC
// Purpose: compute forward and inverse DFT of the complex signal
// Arguments:
// pDFTSpec - pointer to DFT context
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// pSrcRe - pointer to real part of source signal
// pSrcIm - pointer to imaginary part of source signal
// pDstRe - pointer to real part of destination signal
// pDstIm - pointer to imaginary part of destination signal
// pBuffer - pointer to work buffer
// scaleFactor
// - scale factor for output result
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDFTSpec == NULL or
// pSrc == NULL or pDst == NULL or
// pSrcRe == NULL or pSrcIm == NULL or
// pDstRe == NULL or pDstIm == NULL or
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsDFTFwd_CToC_16sc_Sfs,
( const Ipp16sc* pSrc, Ipp16sc* pDst,
const IppsDFTSpec_C_16sc* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_16sc_Sfs,
( const Ipp16sc* pSrc, Ipp16sc* pDst,
const IppsDFTSpec_C_16sc* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_CToC_16s_Sfs,
( const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDstRe, Ipp16s* pDstIm,
const IppsDFTSpec_C_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_16s_Sfs,
( const Ipp16s* pSrcRe, const Ipp16s* pSrcIm,
Ipp16s* pDstRe, Ipp16s* pDstIm,
const IppsDFTSpec_C_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_CToC_32f,
( const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDstRe, Ipp32f* pDstIm,
const IppsDFTSpec_C_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_32f,
( const Ipp32f* pSrcRe, const Ipp32f* pSrcIm,
Ipp32f* pDstRe, Ipp32f* pDstIm,
const IppsDFTSpec_C_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_CToC_64f,
( const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDstRe, Ipp64f* pDstIm,
const IppsDFTSpec_C_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CToC_64f,
( const Ipp64f* pSrcRe, const Ipp64f* pSrcIm,
Ipp64f* pDstRe, Ipp64f* pDstIm,
const IppsDFTSpec_C_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTOutOrdFwd_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTOutOrdInv_CToC_32fc,
( const Ipp32fc* pSrc, Ipp32fc* pDst,
const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTOutOrdFwd_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsDFTOutOrdSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTOutOrdInv_CToC_64fc,
( const Ipp64fc* pSrc, Ipp64fc* pDst,
const IppsDFTOutOrdSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// DFT Real Packed Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDFTFwd_RToPerm, ippsDFTFwd_RToPack, ippsDFTFwd_RToCCS
// ippsDFTInv_PermToR, ippsDFTInv_PackToR, ippsDFTInv_CCSToR
// Purpose: compute forward and inverse DFT of real signal
// using Perm, Pack or Ccs packed format
// Arguments:
// pDFTSpec - pointer to DFT context
// pSrc - pointer to source signal
// pDst - pointer to destination signal
// pBuffer - pointer to work buffer
// scaleFactor
// - scale factor for output result
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDFTSpec == NULL or
// pSrc == NULL or pDst == NULL
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsDFTFwd_RToPerm_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToPack_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToCCS_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PermToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PackToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CCSToR_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDFTSpec_R_16s* pDFTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToPerm_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToPack_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToCCS_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PermToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PackToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CCSToR_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToPerm_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToPack_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTFwd_RToCCS_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PermToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_PackToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDFTInv_CCSToR_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Vector multiplication in RCPack and in RCPerm formats
///////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsMulPack, ippsMulPerm
// Purpose: multiply two vectors stored in RCPack and RCPerm formats
// Parameters:
// pSrc pointer to input vector (in-place case)
// pSrcDst pointer to output vector (in-place case)
// pSrc1 pointer to first input vector
// pSrc2 pointer to second input vector
// pDst pointer to output vector
// length vector's length
// scaleFactor scale factor
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr vector`s length is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsMulPack_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst, int length, int scaleFactor))
IPPAPI(IppStatus, ippsMulPerm_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst, int length, int scaleFactor))
IPPAPI(IppStatus, ippsMulPack_32f_I, (const Ipp32f* pSrc, Ipp32f* pSrcDst, int length))
IPPAPI(IppStatus, ippsMulPerm_32f_I, (const Ipp32f* pSrc, Ipp32f* pSrcDst, int length))
IPPAPI(IppStatus, ippsMulPack_64f_I, (const Ipp64f* pSrc, Ipp64f* pSrcDst, int length))
IPPAPI(IppStatus, ippsMulPerm_64f_I, (const Ipp64f* pSrc, Ipp64f* pSrcDst, int length))
IPPAPI(IppStatus, ippsMulPack_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, Ipp16s* pDst, int length, int scaleFactor))
IPPAPI(IppStatus, ippsMulPerm_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, Ipp16s* pDst, int length, int scaleFactor))
IPPAPI(IppStatus, ippsMulPack_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, int length))
IPPAPI(IppStatus, ippsMulPerm_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, int length))
IPPAPI(IppStatus, ippsMulPack_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, int length))
IPPAPI(IppStatus, ippsMulPerm_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, int length))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsMulPackConj
// Purpose: multiply on a complex conjugate vector and store in RCPack format
// Parameters:
// pSrc pointer to input vector (in-place case)
// pSrcDst pointer to output vector (in-place case)
// length vector's length
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr vector`s length is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsMulPackConj_32f_I, (const Ipp32f* pSrc, Ipp32f* pSrcDst, int length))
IPPAPI(IppStatus, ippsMulPackConj_64f_I, (const Ipp64f* pSrc, Ipp64f* pSrcDst, int length))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsGoertz
// Purpose: compute DFT for single frequency (Goertzel algorithm)
// Parameters:
// freq single relative frequency value [0, 1.0)
// pSrc pointer to the input vector
// len length of the vector
// pVal pointer to the DFT result value computed
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsRelFreqErr frequency value out of range
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsGoertz_32fc, (const Ipp32fc* pSrc, int len, Ipp32fc* pVal, Ipp32f rFreq))
IPPAPI(IppStatus, ippsGoertz_64fc, (const Ipp64fc* pSrc, int len, Ipp64fc* pVal, Ipp64f rFreq))
IPPAPI(IppStatus, ippsGoertz_16sc_Sfs, (const Ipp16sc* pSrc, int len, Ipp16sc* pVal, Ipp32f rFreq, int scaleFactor))
IPPAPI(IppStatus, ippsGoertz_32f, (const Ipp32f* pSrc, int len, Ipp32fc* pVal, Ipp32f rFreq))
IPPAPI(IppStatus, ippsGoertz_16s_Sfs, (const Ipp16s* pSrc, int len, Ipp16sc* pVal, Ipp32f rFreq, int scaleFactor))
IPPAPI(IppStatus, ippsGoertz_64f, (const Ipp64f* pSrc, int len, Ipp64fc* pVal, Ipp64f rFreq))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsGoertzTwo
// Purpose: compute DFT for dual frequency (Goertzel algorithm)
// Parameters:
// freq pointer to two relative frequency values [0, 1.0)
// pSrc pointer to the input vector
// len length of the vector
// pVal pointer to the DFT result value computed
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsRelFreqErr frequency values out of range
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsGoertzTwo_32fc, (const Ipp32fc* pSrc, int len,
Ipp32fc val[2], const Ipp32f rFreq[2] ))
IPPAPI(IppStatus, ippsGoertzTwo_64fc, (const Ipp64fc* pSrc, int len,
Ipp64fc val[2], const Ipp64f rFreq[2] ))
IPPAPI(IppStatus, ippsGoertzTwo_16sc_Sfs, (const Ipp16sc* pSrc, int len,
Ipp16sc val[2], const Ipp32f rFreq[2], int scaleFactor))
IPPAPI(IppStatus, ippsGoertzTwo_32f, (const Ipp32f* pSrc, int len,
Ipp32fc val[2], const Ipp32f rFreq[2] ))
IPPAPI(IppStatus, ippsGoertzTwo_64f, (const Ipp64f* pSrc, int len,
Ipp64fc val[2], const Ipp64f rFreq[2] ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsGoertzQ15
// Purpose: compute DFT for single frequency (Goertzel algorithm)
// Parameters:
// rFreqQ15 single relative frequency value [0, 32767]
// pSrc pointer to the input vector
// len length of the vector
// pVal pointer to the DFT result value computed
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsRelFreqErr frequency value out of range
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsGoertzQ15_16sc_Sfs,
( const Ipp16sc* pSrc, int len, Ipp16sc* pVal,
Ipp16s rFreqQ15, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsGoertzTwoQ15
// Purpose: compute DFT for dual frequency (Goertzel algorithm)
// Parameters:
// rFreqQ15 pointer to two relative frequency values [0, 32767]
// pSrc pointer to the input vector
// len length of the vector
// pVal pointer to the DFT result value computed
// scaleFactor scale factor value
// Return:
// ippStsNullPtrErr pointer to the data is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsRelFreqErr frequency values out of range
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsGoertzTwoQ15_16sc_Sfs,
( const Ipp16sc* pSrc, int len, Ipp16sc pVal[2],
const Ipp16s rFreqQ15[2], int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Definitions for DCT Functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
typedef struct DCTFwdSpec_16s IppsDCTFwdSpec_16s;
typedef struct DCTInvSpec_16s IppsDCTInvSpec_16s;
typedef struct DCTFwdSpec_32f IppsDCTFwdSpec_32f;
typedef struct DCTInvSpec_32f IppsDCTInvSpec_32f;
typedef struct DCTFwdSpec_64f IppsDCTFwdSpec_64f;
typedef struct DCTInvSpec_64f IppsDCTInvSpec_64f;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// DCT Get Size Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwdGetSize, ippsDCTInvGetSize
// Purpose: get sizes of the DCTSpec and buffers (on bytes)
// Arguments:
// len - number of samples in DCT
// hint - code specific use hints
// pSpecSize - where write size of DCTSpec
// pSpecBufferSize - where write size of buffer for DCTInit functions
// pBufferSize - where write size of buffer for DCT calculation
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSpecSize == NULL or pSpecBufferSize == NULL or
// pBufferSize == NULL
// ippStsSizeErr bad the len value
*/
IPPAPI (IppStatus, ippsDCTFwdGetSize_16s,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetSize_16s,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTFwdGetSize_32f,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetSize_32f,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTFwdGetSize_64f,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetSize_64f,
( int len, IppHintAlgorithm hint,
int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
/* /////////////////////////////////////////////////////////////////////////////
// DCT Context Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwdInit, ippsDCTInvInit
// Purpose: initialize of DCT context
// Arguments:
// len - number of samples in DCT
// hint - code specific use hints
// ppDCTSpec - where write pointer to new context
// pSpec - pointer to area for DCTSpec
// pSpecBuffer - pointer to work buffer
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr ppDCTSpec == NULL or
// pSpec == NULL or pMemInit == NULL
// ippStsSizeErr bad the len value
*/
IPPAPI (IppStatus, ippsDCTFwdInit_16s,
( IppsDCTFwdSpec_16s** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsDCTInvInit_16s,
( IppsDCTInvSpec_16s** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsDCTFwdInit_32f,
( IppsDCTFwdSpec_32f** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsDCTInvInit_32f,
( IppsDCTInvSpec_32f** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsDCTFwdInit_64f,
( IppsDCTFwdSpec_64f** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPPAPI (IppStatus, ippsDCTInvInit_64f,
( IppsDCTInvSpec_64f** ppDCTSpec,
int len, IppHintAlgorithm hint,
Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwdInitAlloc, ippsDCTInvInitAlloc
// Purpose: create and initialize of DCT context
// Arguments:
// len - number of samples in DCT
// hint - code specific use hints
// ppDCTSpec - where write pointer to new context
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr ppDCTSpec == NULL
// ippStsSizeErr bad the len value
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsDCTFwdInitAlloc_16s,
( IppsDCTFwdSpec_16s** ppDCTSpec,
int len, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDCTInvInitAlloc_16s,
( IppsDCTInvSpec_16s** ppDCTSpec,
int len, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDCTFwdInitAlloc_32f,
( IppsDCTFwdSpec_32f** ppDCTSpec,
int len, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDCTInvInitAlloc_32f,
( IppsDCTInvSpec_32f** ppDCTSpec,
int len, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDCTFwdInitAlloc_64f,
( IppsDCTFwdSpec_64f** ppDCTSpec,
int len, IppHintAlgorithm hint ))
IPPAPI (IppStatus, ippsDCTInvInitAlloc_64f,
( IppsDCTInvSpec_64f** ppDCTSpec,
int len, IppHintAlgorithm hint ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwdFree, ippsDCTInvFree
// Purpose: delete DCT context
// Arguments:
// pDCTSpec - pointer to DCT context to be deleted
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDCTSpec == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsDCTFwdFree_16s, ( IppsDCTFwdSpec_16s* pDCTSpec ))
IPPAPI (IppStatus, ippsDCTInvFree_16s, ( IppsDCTInvSpec_16s* pDCTSpec ))
IPPAPI (IppStatus, ippsDCTFwdFree_32f, ( IppsDCTFwdSpec_32f* pDCTSpec ))
IPPAPI (IppStatus, ippsDCTInvFree_32f, ( IppsDCTInvSpec_32f* pDCTSpec ))
IPPAPI (IppStatus, ippsDCTFwdFree_64f, ( IppsDCTFwdSpec_64f* pDCTSpec ))
IPPAPI (IppStatus, ippsDCTInvFree_64f, ( IppsDCTInvSpec_64f* pDCTSpec ))
/* /////////////////////////////////////////////////////////////////////////////
// DCT Buffer Size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwdGetBufSize, ippsDCTInvGetBufSize
// Purpose: get size of the DCT work buffer (on bytes)
// Arguments:
// pDCTSpec - pointer to the DCT structure
// pBufferSize - pointer to the DCT work buffer size value
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDCTSpec == NULL or pSize == NULL
// ippStsContextMatchErr bad context identifier
*/
IPPAPI (IppStatus, ippsDCTFwdGetBufSize_16s,
( const IppsDCTFwdSpec_16s* pDCTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetBufSize_16s,
( const IppsDCTInvSpec_16s* pDCTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTFwdGetBufSize_32f,
( const IppsDCTFwdSpec_32f* pDCTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetBufSize_32f,
( const IppsDCTInvSpec_32f* pDCTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTFwdGetBufSize_64f,
( const IppsDCTFwdSpec_64f* pDCTSpec, int* pBufferSize ))
IPPAPI (IppStatus, ippsDCTInvGetBufSize_64f,
( const IppsDCTInvSpec_64f* pDCTSpec, int* pBufferSize ))
/* /////////////////////////////////////////////////////////////////////////////
// DCT Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsDCTFwd, ippsDCTInv
// Purpose: compute forward and inverse DCT of signal
// Arguments:
// pDCTSpec - pointer to DCT context
// pSrc - pointer to source signal
// pDst - pointer to destination signal
// pSrcDst - pointer to signal
// pBuffer - pointer to work buffer
// scaleFactor
// - scale factor for output result
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pDCTSpec == NULL or
// pSrc == NULL or pDst == NULL or pSrcDst == NULL
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI (IppStatus, ippsDCTFwd_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDCTFwdSpec_16s* pDCTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_16s_Sfs,
( const Ipp16s* pSrc, Ipp16s* pDst,
const IppsDCTInvSpec_16s* pDCTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTFwd_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsDCTFwdSpec_16s* pDCTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_16s_ISfs,
( Ipp16s* pSrcDst,
const IppsDCTInvSpec_16s* pDCTSpec,
int scaleFactor, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTFwd_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDCTFwdSpec_32f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_32f,
( const Ipp32f* pSrc, Ipp32f* pDst,
const IppsDCTInvSpec_32f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTFwd_32f_I,
( Ipp32f* pSrcDst,
const IppsDCTFwdSpec_32f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_32f_I,
( Ipp32f* pSrcDst,
const IppsDCTInvSpec_32f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTFwd_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDCTFwdSpec_64f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_64f,
( const Ipp64f* pSrc, Ipp64f* pDst,
const IppsDCTInvSpec_64f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTFwd_64f_I,
( Ipp64f* pSrcDst,
const IppsDCTFwdSpec_64f* pDCTSpec, Ipp8u* pBuffer ))
IPPAPI (IppStatus, ippsDCTInv_64f_I,
( Ipp64f* pSrDst,
const IppsDCTInvSpec_64f* pDCTSpec, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Wavelet Transform Functions for Fixed Filter Banks
///////////////////////////////////////////////////////////////////////////// */
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTHaar
// Purpose: one level Haar Wavelet Transform
// Arguments:
// pSrc - source vector;
// len - length of source vector;
// pDstLow - coarse "low frequency" component destination;
// pDstHigh - detail "high frequency" component destination;
// pSrcLow - coarse "low frequency" component source;
// pSrcHigh - detail "high frequency" component source;
// pDst - destination vector;
// scaleFactor - scale factor value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr the length is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI (IppStatus, ippsWTHaarFwd_8s,
( const Ipp8s* pSrc, int len,
Ipp8s* pDstLow, Ipp8s* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_16s,
( const Ipp16s* pSrc, int len,
Ipp16s* pDstLow, Ipp16s* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_32s,
( const Ipp32s* pSrc, int len,
Ipp32s* pDstLow, Ipp32s* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_64s,
( const Ipp64s* pSrc, int len,
Ipp64s* pDstLow, Ipp64s* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_32f,
( const Ipp32f* pSrc, int len,
Ipp32f* pDstLow, Ipp32f* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_64f,
( const Ipp64f* pSrc, int len,
Ipp64f* pDstLow, Ipp64f* pDstHigh ))
IPPAPI (IppStatus, ippsWTHaarFwd_8s_Sfs,
( const Ipp8s* pSrc, int len,
Ipp8s* pDstLow, Ipp8s* pDstHigh, int scaleFactor))
IPPAPI (IppStatus, ippsWTHaarFwd_16s_Sfs,
( const Ipp16s* pSrc, int len,
Ipp16s* pDstLow, Ipp16s* pDstHigh, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarFwd_32s_Sfs,
( const Ipp32s* pSrc, int len,
Ipp32s* pDstLow, Ipp32s* pDstHigh, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarFwd_64s_Sfs,
( const Ipp64s* pSrc, int len,
Ipp64s* pDstLow, Ipp64s* pDstHigh, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarInv_8s,
( const Ipp8s* pSrcLow, const Ipp8s* pSrcHigh,
Ipp8s* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_16s,
( const Ipp16s* pSrcLow, const Ipp16s* pSrcHigh,
Ipp16s* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_32s,
( const Ipp32s* pSrcLow, const Ipp32s* pSrcHigh,
Ipp32s* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_64s,
( const Ipp64s* pSrcLow, const Ipp64s* pSrcHigh,
Ipp64s* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_32f,
( const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh,
Ipp32f* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_64f,
( const Ipp64f* pSrcLow, const Ipp64f* pSrcHigh,
Ipp64f* pDst, int len ))
IPPAPI (IppStatus, ippsWTHaarInv_8s_Sfs,
( const Ipp8s* pSrcLow, const Ipp8s* pSrcHigh,
Ipp8s* pDst, int len, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarInv_16s_Sfs,
( const Ipp16s* pSrcLow, const Ipp16s* pSrcHigh,
Ipp16s* pDst, int len, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarInv_32s_Sfs,
( const Ipp32s* pSrcLow, const Ipp32s* pSrcHigh,
Ipp32s* pDst, int len, int scaleFactor ))
IPPAPI (IppStatus, ippsWTHaarInv_64s_Sfs,
( const Ipp64s* pSrcLow, const Ipp64s* pSrcHigh,
Ipp64s* pDst, int len, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Wavelet Transform Fucntions for User Filter Banks
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct sWTFwdState_32f;
typedef struct sWTFwdState_32f IppsWTFwdState_32f;
struct sWTFwdState_8s32f;
typedef struct sWTFwdState_8s32f IppsWTFwdState_8s32f;
struct sWTFwdState_8u32f;
typedef struct sWTFwdState_8u32f IppsWTFwdState_8u32f;
struct sWTFwdState_16s32f;
typedef struct sWTFwdState_16s32f IppsWTFwdState_16s32f;
struct sWTFwdState_16u32f;
typedef struct sWTFwdState_16u32f IppsWTFwdState_16u32f;
struct sWTInvState_32f;
typedef struct sWTInvState_32f IppsWTInvState_32f;
struct sWTInvState_32f8s;
typedef struct sWTInvState_32f8s IppsWTInvState_32f8s;
struct sWTInvState_32f8u;
typedef struct sWTInvState_32f8u IppsWTInvState_32f8u;
struct sWTInvState_32f16s;
typedef struct sWTInvState_32f16s IppsWTInvState_32f16s;
struct sWTInvState_32f16u;
typedef struct sWTInvState_32f16u IppsWTInvState_32f16u;
#endif /* _OWN_BLDPCS */
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTFwdInitAlloc_32f, ippsWTFwdInitAlloc_8s32f,
// ippsWTFwdInitAlloc_8u32f, ippsWTFwdInitAlloc_16s32f,
// ippsWTFwdInitAlloc_16u32f
//
// Purpose: Allocate and initialize
// forward wavelet transform pState structure.
// Parameters:
// pState - pointer to pointer to allocated and initialized
// pState structure.
// pTapsLow - pointer to lowpass filter taps;
// lenLow - length of lowpass filter;
// offsLow - input delay of lowpass filter;
// pTapsHigh - pointer to highpass filter taps;
// lenHigh - length of highpass filter;
// offsHigh - input delay of highpass filter;
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - pointer to filter taps are NULL
// or pointer to pState structure is NULL;
// ippStsSizeErr - filter length is less or equal zero;
// ippStsWtOffsetErr - filter delay is less than (-1).
//
// Notes: filter input delay minimum value is (-1) that corresponds to
// downsampling phase equal 1 (first sample excluded,
// second included and so on);
*/
IPPAPI (IppStatus, ippsWTFwdInitAlloc_32f, (IppsWTFwdState_32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTFwdInitAlloc_8s32f, (IppsWTFwdState_8s32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTFwdInitAlloc_8u32f, (IppsWTFwdState_8u32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTFwdInitAlloc_16s32f, (IppsWTFwdState_16s32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTFwdInitAlloc_16u32f, (IppsWTFwdState_16u32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTFwdSetDlyLine_32f, ippsWTFwdSetDlyLine_8s32f,
// ippsWTFwdSetDlyLine_8u32f, ippsWTFwdSetDlyLine_16s32f,
// ippsWTFwdSetDlyLine_16u32f
//
// Purpose: The function copies the pointed vectors to internal delay lines.
//
// Parameters:
// pState - pointer to pState structure;
// pDlyLow - pointer to delay line for lowpass filtering;
// pDlyHigh - pointer to delay line for highpass filtering.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers pDlyLow
// or pDlyHigh vectors are NULL;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: lengths of delay lines:
// len(pDlyLow) = lenLow + offsLow - 1;
// len(pDlyHigh) = lenHigh + offsHigh - 1;
// lenLow, offsLow, lenHigh, offsHigh - parameters
// for ippsWTFwdInitAlloc function.
*/
IPPAPI (IppStatus, ippsWTFwdSetDlyLine_32f, (IppsWTFwdState_32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdSetDlyLine_8s32f, (IppsWTFwdState_8s32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdSetDlyLine_8u32f, (IppsWTFwdState_8u32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdSetDlyLine_16s32f, (IppsWTFwdState_16s32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdSetDlyLine_16u32f, (IppsWTFwdState_16u32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTFwdGetDlyLine_32f, ippsWTFwdGetDlyLine_8s32f,
// ippsWTFwdGetDlyLine_8u32f, ippsWTFwdGetDlyLine_16s32f,
// ippsWTFwdGetDlyLine_16u32f
//
// Purpose: The function copies data from interanl delay lines
// to the pointed vectors.
// Parameters:
// pState - pointer to pState structure;
// pDlyLow - pointer to delay line for lowpass filtering;
// pDlyHigh - pointer to delay line for highpass filtering.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers pDlyLow
// or pDlyHigh vectors are NULL;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: lengths of delay lines:
// len(pDlyLow) = lenLow + offsLow - 1;
// len(pDlyHigh) = lenHigh + offsHigh - 1;
// lenLow, offsLow, lenHigh, offsHigh - parameters
// for ippsWTFwdInitAlloc function.
*/
IPPAPI (IppStatus, ippsWTFwdGetDlyLine_32f, (IppsWTFwdState_32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdGetDlyLine_8s32f, (IppsWTFwdState_8s32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdGetDlyLine_8u32f, (IppsWTFwdState_8u32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdGetDlyLine_16s32f, (IppsWTFwdState_16s32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTFwdGetDlyLine_16u32f, (IppsWTFwdState_16u32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTFwd_32f, ippsWTFwd_16s32f, ippsWTFwd_16u32f,
// ippsWTFwd_8s32f, ippsWTFwd_8u32f
//
// Purpose: Forward wavelet transform.
//
// Parameters:
// pSrc - pointer to source block of data;
// pDstLow - pointer to destination block of
// "low-frequency" component;
// pDstHigh - pointer to destination block of
// "high-frequency" component;
// dstLen - length of destination;
// pState - pointer to pState structure.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers to pSrc, pDstLow
// or pDstHigh vectors are NULL;
// ippStsSizeErr - the length is less or equal zero;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: source block length must be 2 * dstLen.
*/
IPPAPI (IppStatus, ippsWTFwd_32f, (const Ipp32f* pSrc,
Ipp32f* pDstLow, Ipp32f* pDstHigh, int dstLen,
IppsWTFwdState_32f* pState))
IPPAPI (IppStatus, ippsWTFwd_8s32f, (const Ipp8s* pSrc,
Ipp32f* pDstLow, Ipp32f* pDstHigh, int dstLen,
IppsWTFwdState_8s32f* pState))
IPPAPI (IppStatus, ippsWTFwd_8u32f, (const Ipp8u* pSrc,
Ipp32f* pDstLow, Ipp32f* pDstHigh, int dstLen,
IppsWTFwdState_8u32f* pState))
IPPAPI (IppStatus, ippsWTFwd_16s32f, (const Ipp16s* pSrc,
Ipp32f* pDstLow, Ipp32f* pDstHigh, int dstLen,
IppsWTFwdState_16s32f* pState))
IPPAPI (IppStatus, ippsWTFwd_16u32f, (
const Ipp16u* pSrc, Ipp32f* pDstLow, Ipp32f* pDstHigh, int dstLen,
IppsWTFwdState_16u32f* pState))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTFwdFree_32f, ippsWTFwdFree_8s32f, ippsWTFwdFree_8u32f,
// ippsWTFwdFree_16s32f, ippsWTFwdFree_16u32f
//
// Purpose: Free and Deallocate forward wavelet transofrm pState structure.
//
// Parameters:
// IppsWTFwdState_32f *pState - pointer to pState structure.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - Pointer to pState structure is NULL;
// ippStspStateMatchErr - Mismatch pState structure.
//
// Notes: if pointer to pState is NULL, ippStsNoErr will be returned.
*/
IPPAPI (IppStatus, ippsWTFwdFree_32f, (IppsWTFwdState_32f* pState))
IPPAPI (IppStatus, ippsWTFwdFree_8s32f, (IppsWTFwdState_8s32f* pState))
IPPAPI (IppStatus, ippsWTFwdFree_8u32f, (IppsWTFwdState_8u32f* pState))
IPPAPI (IppStatus, ippsWTFwdFree_16s32f, (IppsWTFwdState_16s32f* pState))
IPPAPI (IppStatus, ippsWTFwdFree_16u32f, (IppsWTFwdState_16u32f* pState))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTInvInitAlloc_32f, ippsWTInvInitAlloc_32f8s,
// ippsWTInvInitAlloc_32f8u, ippsWTInvInitAlloc_32f16s,
// ippsWTInvInitAlloc_32f16u
//
// Purpose: Allocate and initialize
// inverse wavelet transform pState structure.
// Parameters:
// pState - pointer to pointer to allocated and initialized
// pState structure.
// pTapsLow - pointer to lowpass filter taps;
// lenLow - length of lowpass filter;
// offsLow - input delay of lowpass filter;
// pTapsHigh - pointer to highpass filter taps;
// lenHigh - length of highpass filter;
// offsHigh - input delay of highpass filter;
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - pointer to filter taps are NULL
// or pointer to pState structure is NULL;
// ippStsSizeErr - filter length is less or equal zero;
// ippStsWtOffsetErr - filter delay is less than (-1).
//
// Notes: filter output delay minimum value is 0 that corresponds to
// upsampling phase equal 0 (first sample included,
// second sample is zero and so on);
// pointer to returned error status may be NULL if no error
// diagnostic required.
*/
IPPAPI (IppStatus, ippsWTInvInitAlloc_32f, (IppsWTInvState_32f** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTInvInitAlloc_32f8s, (IppsWTInvState_32f8s** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTInvInitAlloc_32f8u, (IppsWTInvState_32f8u** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTInvInitAlloc_32f16s, (IppsWTInvState_32f16s** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
IPPAPI (IppStatus, ippsWTInvInitAlloc_32f16u, (IppsWTInvState_32f16u** pState,
const Ipp32f* pTapsLow, int lenLow, int offsLow,
const Ipp32f* pTapsHigh, int lenHigh, int offsHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTInvSetDlyLine_32f, ippsWTInvSetDlyLine_32f8s,
// ippsWTInvSetDlyLine_32f8u, ippsWTInvSetDlyLine_32f16s,
// ippsWTInvSetDlyLine_32f16u
//
// Purpose: The function copies the pointed vectors to internal delay lines.
//
// Parameters:
// pState - pointer to pState structure;
// pDlyLow - pointer to delay line for lowpass filtering;
// pDlyHigh - pointer to delay line for highpass filtering.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers pDlyLow
// or pDlyHigh vectors are NULL;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: lengths of delay lines (as "C" expression):
// len(pDlyLow) = (lenLow + offsLow - 1) / 2;
// len(pDlyHigh) = (lenHigh + offsHigh - 1) / 2;
// lenLow, offsLow, lenHigh, offsHigh - parameters
// for ippsWTInvInitAlloc function.
*/
IPPAPI (IppStatus, ippsWTInvSetDlyLine_32f, (IppsWTInvState_32f* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvSetDlyLine_32f8s, (IppsWTInvState_32f8s* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvSetDlyLine_32f8u, (IppsWTInvState_32f8u* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvSetDlyLine_32f16s, (IppsWTInvState_32f16s* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvSetDlyLine_32f16u, (IppsWTInvState_32f16u* pState,
const Ipp32f* pDlyLow, const Ipp32f* pDlyHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTInvGetDlyLine_32f, ippsWTInvGetDlyLine_32f8s,
// ippsWTInvGetDlyLine_32f8u, ippsWTInvGetDlyLine_32f16s,
// ippsWTInvGetDlyLine_32f16u
//
// Purpose: The function copies data from interanl delay lines
// to the pointed vectors.
// Parameters:
// pState - pointer to pState structure;
// pDlyLow - pointer to delay line for lowpass filtering;
// pDlyHigh - pointer to delay line for highpass filtering.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers pDlyLow
// or pDlyHigh vectors are NULL;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: lengths of delay lines (as "C" expression):
// len(pDlyLow) = (lenLow + offsLow - 1) / 2;
// len(pDlyHigh) = (lenHigh + offsHigh - 1) / 2;
// lenLow, offsLow, lenHigh, offsHigh - parameters
// for ippsWTInvInitAlloc function.
*/
IPPAPI (IppStatus, ippsWTInvGetDlyLine_32f, (IppsWTInvState_32f* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvGetDlyLine_32f8s, (IppsWTInvState_32f8s* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvGetDlyLine_32f8u, (IppsWTInvState_32f8u* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvGetDlyLine_32f16s, (IppsWTInvState_32f16s* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
IPPAPI (IppStatus, ippsWTInvGetDlyLine_32f16u, (IppsWTInvState_32f16u* pState,
Ipp32f* pDlyLow, Ipp32f* pDlyHigh))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTInv_32f, ippsWTInv_32f16s, ippsWTInv_32f16u,
// ippsWTInv_32f8s, ippsWTInv_32f8u
//
// Purpose: Inverse wavelet transform.
//
// Parameters:
// srcLow - pointer to source block of
// "low-frequency" component;
// srcHigh - pointer to source block of
// "high-frequency" component;
// dstLen - length of components.
// dst - pointer to destination block of
// reconstructed data;
// pState - pointer to pState structure;
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - some of pointers to pDst pSrcLow
// or pSrcHigh vectors are NULL;
// ippStsSizeErr - the length is less or equal zero;
// ippStspStateMatchErr - mismatch pState structure.
//
// Notes: destination block length must be 2 * srcLen.
*/
IPPAPI (IppStatus, ippsWTInv_32f, (
const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh, int srcLen, Ipp32f* pDst,
IppsWTInvState_32f* pState))
IPPAPI (IppStatus, ippsWTInv_32f8s, (
const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh, int srcLen, Ipp8s* pDst,
IppsWTInvState_32f8s* pState))
IPPAPI (IppStatus, ippsWTInv_32f8u, (
const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh, int srcLen, Ipp8u* pDst,
IppsWTInvState_32f8u* pState))
IPPAPI (IppStatus, ippsWTInv_32f16s, (
const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh, int srcLen, Ipp16s* pDst,
IppsWTInvState_32f16s* pState))
IPPAPI (IppStatus, ippsWTInv_32f16u, (
const Ipp32f* pSrcLow, const Ipp32f* pSrcHigh, int srcLen, Ipp16u* pDst,
IppsWTInvState_32f16u* pState))
/* //////////////////////////////////////////////////////////////////////
// Name: ippsWTInvFree_32f, ippsWTInvFree_32f8s, ippsWTInvFree_32f8u,
// ippsWTInvFree_32f16s, ippsWTInvFree_32f16u
//
// Purpose: Free and Deallocate inverse wavelet transofrm pState structure.
//
// Parameters:
// IppsWTInvState_32f *pState - pointer to pState structure.
//
// Returns:
// ippStsNoErr - Ok;
// ippStsNullPtrErr - Pointer to pState structure is NULL;
// ippStspStateMatchErr - Mismatch pState structure.
//
// Notes: if pointer to pState is NULL, ippStsNoErr will be returned.
*/
IPPAPI (IppStatus, ippsWTInvFree_32f, (IppsWTInvState_32f* pState))
IPPAPI (IppStatus, ippsWTInvFree_32f8s, (IppsWTInvState_32f8s* pState))
IPPAPI (IppStatus, ippsWTInvFree_32f8u, (IppsWTInvState_32f8u* pState))
IPPAPI (IppStatus, ippsWTInvFree_32f16s, (IppsWTInvState_32f16s* pState))
IPPAPI (IppStatus, ippsWTInvFree_32f16u, (IppsWTInvState_32f16u* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Filtering
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Convolution functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConv
// Purpose: Linear Convolution of 1D signals
// Parameters:
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// lenSrc1 length of the first source vector
// lenSrc2 length of the second source vector
// pDst pointer to the destination vector
// Returns: IppStatus
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsMemAllocErr no memory for internal buffers
// ippStsNoErr otherwise
// Notes:
// Length of the destination data vector is lenSrc1+lenSrc2-1.
// The input signal are exchangeable because of
// commutative convolution property.
// Some other values may be returned by FFT transform functions
*/
IPPAPI(IppStatus, ippsConv_32f, ( const Ipp32f* pSrc1, int lenSrc1,
const Ipp32f* pSrc2, int lenSrc2, Ipp32f* pDst))
IPPAPI(IppStatus, ippsConv_16s_Sfs, ( const Ipp16s* pSrc1, int lenSrc1,
const Ipp16s* pSrc2, int lenSrc2, Ipp16s* pDst, int scaleFactor))
IPPAPI( IppStatus, ippsConv_64f,( const Ipp64f* pSrc1, int lenSrc1,
const Ipp64f* pSrc2, int lenSrc2, Ipp64f* pDst))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvBiased_32f
// Purpose: Linear Convolution of 1D signals whith a bias.
// Parameters:
// pSrc1 pointer to the first source vector
// pSrc2 pointer to the second source vector
// lenSrc1 length of the first source vector
// lenSrc2 length of the second source vector
// pDst pointer to the destination vector
// lenDst length of the destination vector
// bias
// Returns: IppStatus
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsConvBiased_32f,
( const Ipp32f *pSrc1, int len1,
const Ipp32f *pSrc2, int len2,
Ipp32f *pDst, int lenDst, int bias ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsConvCyclic
// Purpose: Cyclic Convolution of 1D signals of fixed size
// Parameters: the pointers to data of fixed size
// Returns: IppStatus
// ippStsNoErr parameters are not checked
// Notes:
// The length of the convolution is given in the function name.
*/
IPPAPI(IppStatus, ippsConvCyclic8x8_32f,( const Ipp32f* x,
const Ipp32f* h, Ipp32f* y ))
IPPAPI(IppStatus, ippsConvCyclic8x8_16s_Sfs,( const Ipp16s* x,
const Ipp16s* h, Ipp16s* y, int scaleFactor ))
IPPAPI(IppStatus, ippsConvCyclic4x4_32f32fc,( const Ipp32f* x,
const Ipp32fc* h, Ipp32fc* y ))
/* /////////////////////////////////////////////////////////////////////////////
// IIR filters (float and double taps versions)
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct IIRState_32f;
typedef struct IIRState_32f IppsIIRState_32f;
struct IIRState_32fc;
typedef struct IIRState_32fc IppsIIRState_32fc;
struct IIRState32f_16s;
typedef struct IIRState32f_16s IppsIIRState32f_16s;
struct IIRState32fc_16sc;
typedef struct IIRState32fc_16sc IppsIIRState32fc_16sc;
struct IIRState_64f;
typedef struct IIRState_64f IppsIIRState_64f;
struct IIRState_64fc;
typedef struct IIRState_64fc IppsIIRState_64fc;
struct IIRState64f_32f;
typedef struct IIRState64f_32f IppsIIRState64f_32f;
struct IIRState64fc_32fc;
typedef struct IIRState64fc_32fc IppsIIRState64fc_32fc;
struct IIRState64f_32s;
typedef struct IIRState64f_32s IppsIIRState64f_32s;
struct IIRState64fc_32sc;
typedef struct IIRState64fc_32sc IppsIIRState64fc_32sc;
struct IIRState64f_16s;
typedef struct IIRState64f_16s IppsIIRState64f_16s;
struct IIRState64fc_16sc;
typedef struct IIRState64fc_16sc IppsIIRState64fc_16sc;
struct IIRState32s_16s;
typedef struct IIRState32s_16s IppsIIRState32s_16s;
struct IIRState32sc_16sc;
typedef struct IIRState32sc_16sc IppsIIRState32sc_16sc;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Initialize context
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRInitAlloc, ippsIIRFree
// Purpose: initialize context arbitrary order IIR filter
// Parameters:
// ppState - double pointer to filter context
// pState - pointer to filter context
// pTaps - pointer to filter coefficients
// order - arbitrary filter order
// pDelay - pointer to delay line data, can be NULL
// Return: IppStatus
// ippStsMemAllocErr - memory allocation error
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsIIROrderErr - filter order < 0
// ippStsDivByZeroErr - A(0) is zero
// ippStsContextMatchErr - wrong context identifier
// ippStsNoErr - otherwise
// Order of the coefficients in the input taps buffer:
// B(0),B(1),B(2)..,B(order);
// A(0),A(1),A(2)..,A(order);
// . . .
// Note:
// A(0) != 0
// ippsIIRClose function works for both AR and BQ contexts
*/
IPPAPI(IppStatus, ippsIIRInitAlloc_32f, (IppsIIRState_32f** ppState,
const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_32fc, (IppsIIRState_32fc** ppState,
const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32f_16s, (IppsIIRState32f_16s** ppState,
const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32fc_16sc, (IppsIIRState32fc_16sc** ppState,
const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_64f, (IppsIIRState_64f** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_64fc, (IppsIIRState_64fc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_32f, (IppsIIRState64f_32f** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_32fc, (IppsIIRState64fc_32fc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_32s, (IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_32sc, (IppsIIRState64fc_32sc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_16s, (IppsIIRState64f_16s** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_16sc, (IppsIIRState64fc_16sc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRFree_32f, (IppsIIRState_32f* pState))
IPPAPI(IppStatus, ippsIIRFree_32fc, (IppsIIRState_32fc* pState))
IPPAPI(IppStatus, ippsIIRFree32f_16s, (IppsIIRState32f_16s* pState))
IPPAPI(IppStatus, ippsIIRFree32fc_16sc, (IppsIIRState32fc_16sc* pState))
IPPAPI(IppStatus, ippsIIRFree_64f, (IppsIIRState_64f* pState))
IPPAPI(IppStatus, ippsIIRFree_64fc, (IppsIIRState_64fc* pState))
IPPAPI(IppStatus, ippsIIRFree64f_32f, (IppsIIRState64f_32f* pState))
IPPAPI(IppStatus, ippsIIRFree64fc_32fc, (IppsIIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsIIRFree64f_32s, (IppsIIRState64f_32s* pState))
IPPAPI(IppStatus, ippsIIRFree64fc_32sc, (IppsIIRState64fc_32sc* pState))
IPPAPI(IppStatus, ippsIIRFree64f_16s, (IppsIIRState64f_16s* pState))
IPPAPI(IppStatus, ippsIIRFree64fc_16sc, (IppsIIRState64fc_16sc* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRInitAlloc_BiQuad
// Purpose: initialize biquad numBq-section filter
// Parameters:
// ppState - double pointer to filter context
// pTaps - pointer to filter coefficients
// numBq - number biquads of BQ filter
// pDelay - pointer to delay line data, can be NULL
// Return: IppStatus
// ippStsMemAllocErr - memory allocation error
// ippStsNullPtrErr - pointer(s) ppState or pTaps is NULL
// ippStsIIROrderErr - numBq <= 0
// ippStsDivByZeroErr - A(n,0) or B(n,0) is zero
// ippStsNoErr - otherwise
//
// Order of the coefficients in the input taps buffer:
// B(0,0),B(0,1),B(0,2),A(0,0),A(0,1),A(0,2);
// B(1,0),B(1,1),B(1,2),A(1,0),A(1,1),A(1,2);
// . . .
// Notice:
// A(n,0) != 0 and B(n,0) != 0
*/
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_32f, (IppsIIRState_32f** ppState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_32fc, (IppsIIRState_32fc** ppState,
const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32f_BiQuad_16s, (IppsIIRState32f_16s** ppState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32fc_BiQuad_16sc, (IppsIIRState32fc_16sc** ppState,
const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_64f, (IppsIIRState_64f** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_64fc, (IppsIIRState_64fc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_32f, (IppsIIRState64f_32f** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_BiQuad_32fc, (IppsIIRState64fc_32fc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_32s, (IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_BiQuad_32sc, (IppsIIRState64fc_32sc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_16s, (IppsIIRState64f_16s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_BiQuad_16sc, (IppsIIRState64fc_16sc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRInitAlloc_BiQuad_DF1
// Purpose: initialize biquad numBq-section DF1 filter
// Parameters:
// ppState - double pointer to filter context
// pTaps - pointer to filter coefficients
// numBq - number biquads of BQ filter
// pDelay - pointer to delay line data, can be NULL
// Return: IppStatus
// ippStsMemAllocErr - memory allocation error
// ippStsNullPtrErr - pointer(s) ppState or pTaps is NULL
// ippStsIIROrderErr - numBq <= 0
// ippStsDivByZeroErr - A(n,0) or B(n,0) is zero
// ippStsNoErr - otherwise
//
// Order of the coefficients in the input taps buffer:
// pTaps = B[0,0], B[0,1], B[0,2], A[0,0], A[0,1], A[0,2],
// B[1,0], B[1,1], B[1,2], A[1,0], A[1,1], A[1,2],
// ...
// B[n,0], B[n,1], B[n,2], A[n,0], A[n,1], A[n,2]
// ( n = numBq-1 );
//
// pDLyLine = X[0,-2], X[0,-1], Y[0,-2], Y[0,-1],
// X[1,-2], X[1,-1], Y[1,-2], Y[1,-1],
// ...
// X[n,-2], X[n,-1], Y[n,-2], Y[n,-1],
// ( n = numBq-1 );
// . . .
// Notice:
// A(n,0) != 0
//
// Y[i] = X[i-2]*B[0,2] + X[i-1]*B[0,1] + X[i]*B[0,0] -
// - Y[i-1]*A[0,1] - Y[i-2]*A[0,2];
// Z[i] = Y[i];
// Y[i] = Z[i-2]*B[1,2] + Z[i-1]*B[1,1] + Z[i]*B[1,0] -
// - Y[i-1]*A[1,1] - Y[i-2]*A[1,2];
// Z[i] = Y[i];
// ...
// Y[i] = Z[i-2]*B[j,2] + Z[i-1]*B[j,1] + Z[i]*B[j,0] -
// - Y[i-1]*A[j,1] - Y[i-2]*A[j,2];
// Z[i] = Y[i];
// ...
// Y[i] = Z[i-2]*B[n,2] + Z[i-1]*B[n,1] + Z[i]*B[n,0] -
// - Y[i-1]*A[n,1] - Y[i-2]*A[n,2]; (n=numBq-1)
// pDst[i] = Y[i];
*/
IPPAPI( IppStatus, ippsIIRInitAlloc_BiQuad_DF1_32f,( IppsIIRState_32f** pState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine ))
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_DF1_32s, (IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp32s* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Work with Delay Line
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRGetDlyLine, ippsIIRSetDlyLine
// Purpose: set and get delay line
// Parameters:
// pState - pointer to IIR filter context
// pDelay - pointer to delay line to be set
// Return:
// ippStsContextMatchErr - wrong context identifier
// ippStsNullPtrErr - pointer(s) pState or pDelay is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsIIRGetDlyLine_32f, (const IppsIIRState_32f* pState, Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine_32f, (IppsIIRState_32f* pState, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine_32fc, (const IppsIIRState_32fc* pState, Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine_32fc, (IppsIIRState_32fc* pState, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine32f_16s, (const IppsIIRState32f_16s* pState, Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine32f_16s, (IppsIIRState32f_16s* pState, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine32fc_16sc, (const IppsIIRState32fc_16sc* pState, Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine32fc_16sc, (IppsIIRState32fc_16sc* pState, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine_64f, (const IppsIIRState_64f* pState, Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine_64f, (IppsIIRState_64f* pState, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine_64fc, (const IppsIIRState_64fc* pState, Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine_64fc, (IppsIIRState_64fc* pState, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64f_32f, (const IppsIIRState64f_32f* pState, Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64f_32f, (IppsIIRState64f_32f* pState, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64fc_32fc, (const IppsIIRState64fc_32fc* pState, Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64fc_32fc, (IppsIIRState64fc_32fc* pState, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64f_32s, (const IppsIIRState64f_32s* pState, Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64f_32s, (IppsIIRState64f_32s* pState, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64fc_32sc, (const IppsIIRState64fc_32sc* pState, Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64fc_32sc, (IppsIIRState64fc_32sc* pState, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64f_16s, (const IppsIIRState64f_16s* pState, Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64f_16s, (IppsIIRState64f_16s* pState, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64fc_16sc, (const IppsIIRState64fc_16sc* pState, Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64fc_16sc, (IppsIIRState64fc_16sc* pState, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine64f_DF1_32s, (const IppsIIRState64f_32s* pState, Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine64f_DF1_32s, (IppsIIRState64f_32s* pState, const Ipp32s* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Filtering
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIROne
// Purpose: IIR filter with float or double taps. One sample operation
// Parameters:
// pState - pointer to IIR filter context
// src - input sample
// pDstVal - output sample
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong context identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
//
// Note: Don't modify scaleFactor value unless context is changed
*/
IPPAPI(IppStatus, ippsIIROne_32f, (Ipp32f src, Ipp32f* pDstVal, IppsIIRState_32f* pState))
IPPAPI(IppStatus, ippsIIROne_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsIIRState_32fc* pState))
IPPAPI(IppStatus, ippsIIROne32f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState32f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne32fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, IppsIIRState32fc_16sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne_64f, (Ipp64f src, Ipp64f* pDstVal, IppsIIRState_64f* pState))
IPPAPI(IppStatus, ippsIIROne_64fc, (Ipp64fc src, Ipp64fc* pDstVal, IppsIIRState_64fc* pState))
IPPAPI(IppStatus, ippsIIROne64f_32f, (Ipp32f src, Ipp32f* pDstVal, IppsIIRState64f_32f* pState))
IPPAPI(IppStatus, ippsIIROne64fc_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsIIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsIIROne64f_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal, IppsIIRState64f_32s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne64fc_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal, IppsIIRState64fc_32sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne64f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState64f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne64fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, IppsIIRState64fc_16sc* pState, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIR
// Purpose: IIR filter with float or double taps. Vector filtering
// Parameters:
// pState - pointer to filter context
// pSrcDst - pointer to input/output vector in in-place ops
// pSrc - pointer to input vector
// pDst - pointer to output vector
// len - length of the vectors
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong context identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - length of the vectors <= 0
// ippStsNoErr - otherwise
//
// Note: Don't modify scaleFactor value unless context is changed
*/
IPPAPI(IppStatus, ippsIIR_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len,
IppsIIRState_32f* pState))
IPPAPI(IppStatus, ippsIIR_32f_I, (Ipp32f* pSrcDst, int len, IppsIIRState_32f* pState))
IPPAPI(IppStatus, ippsIIR_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len,
IppsIIRState_32fc* pState))
IPPAPI(IppStatus, ippsIIR_32fc_I, (Ipp32fc* pSrcDst, int len, IppsIIRState_32fc* pState))
IPPAPI(IppStatus, ippsIIR32f_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int len,
IppsIIRState32f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR32f_16s_ISfs, (Ipp16s* pSrcDst, int len,
IppsIIRState32f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR32fc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len,
IppsIIRState32fc_16sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR32fc_16sc_ISfs, (Ipp16sc* pSrcDst, int len,
IppsIIRState32fc_16sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len,
IppsIIRState_64f* pState))
IPPAPI(IppStatus, ippsIIR_64f_I, (Ipp64f* pSrcDst, int len, IppsIIRState_64f* pState))
IPPAPI(IppStatus, ippsIIR_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int len,
IppsIIRState_64fc* pState))
IPPAPI(IppStatus, ippsIIR_64fc_I, (Ipp64fc* pSrcDst, int len, IppsIIRState_64fc* pState))
IPPAPI(IppStatus, ippsIIR64f_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len,
IppsIIRState64f_32f* pState))
IPPAPI(IppStatus, ippsIIR64f_32f_I, (Ipp32f* pSrcDst, int len, IppsIIRState64f_32f* pState))
IPPAPI(IppStatus, ippsIIR64fc_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len,
IppsIIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsIIR64fc_32fc_I, (Ipp32fc* pSrcDst, int len, IppsIIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsIIR64f_32s_Sfs, (const Ipp32s* pSrc, Ipp32s* pDst, int len,
IppsIIRState64f_32s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64f_32s_ISfs, (Ipp32s* pSrcDst, int len,
IppsIIRState64f_32s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64fc_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc* pDst, int len,
IppsIIRState64fc_32sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64fc_32sc_ISfs, (Ipp32sc* pSrcDst, int len,
IppsIIRState64fc_32sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64f_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int len,
IppsIIRState64f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64f_16s_ISfs, (Ipp16s* pSrcDst, int len,
IppsIIRState64f_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64fc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len,
IppsIIRState64fc_16sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR64fc_16sc_ISfs, (Ipp16sc* pSrcDst, int len,
IppsIIRState64fc_16sc* pState, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIR_32f_P, ippsIIR64f_32s_P
// Purpose: IIR filter for multi-channel data. Vector filtering.
// Parameters:
// ppSrc - pointer to array of pointers to source vectors
// ppDst - pointer to array of pointers to destination vectors
// ppSrcDst - pointer to array of source/destination vectors in in-place ops
// len - length of the vectors
// nChannels - number of processing channels
// ppState - pointer to array of filter contexts
// Return:
// ippStsContextMatchErr - wrong context identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - length of the vectors <= 0
// ippStsChannelErr - number of processing channels <= 0
// ippStsNoErr - otherwise
//
*/
IPPAPI( IppStatus, ippsIIR_32f_P,( const Ipp32f **ppSrc, Ipp32f **ppDst, int len,
int nChannels, IppsIIRState_32f **ppState ))
IPPAPI( IppStatus, ippsIIR_32f_IP,( Ipp32f **ppSrcDst, int len,
int nChannels, IppsIIRState_32f **ppState ))
IPPAPI(IppStatus, ippsIIR64f_32s_PSfs, (const Ipp32s **ppSrc, Ipp32s **ppDst, int len,
int nChannels, IppsIIRState64f_32s **ppState, int *pScaleFactor))
IPPAPI(IppStatus, ippsIIR64f_32s_IPSfs, (Ipp32s **ppSrcDst, int len,
int nChannels, IppsIIRState64f_32s **ppState, int *pScaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// IIR filters (integer taps version)
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Initialize context
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRInitAlloc, ippsIIRInitAlloc_BiQuad, ippsIIRFree
// Purpose: create and initialize IIR context for AR filter
// Parameters:
// ppState - double pointer to filter context
// pState - pointer to filter context
// pTaps - pointer to filter coefficients
// order - arbitrary filter order
// tapsFactor - scale factor for Ipp32s context taps
// numBq - number of biquads in BQ filter
// pDelay - pointer to delay line, may be NULL
// Return:
// ippStsNoErr - Ok
// ippStsMemAllocErr - memory allocate error
// ippStsNullPtrErr - pointer(s) to ppState, pState or pTaps is NULL
// ippStsIIROrderErr - filter order < 0 or numBq <= 0
// ippStsDivByZeroErr - A(0) or A(n,0) or B(n,0) is zero
//
// the Ipp32s taps from the source Ipp32f taps and taps factor
// may be prepared by this way, for example
//
// ippsAbs_64f( taps, tmp, 6 );
// ippsMax_64f( tmp, 6, &tmax );
//
// tapsfactor = 0;
// if( tmax > IPP_MAX_32S )
// while( (tmax/=2) > IPP_MAX_32S ) ++tapsfactor;
// else
// while( (tmax*=2) < IPP_MAX_32S ) --tapsfactor;
//
// if( tapsfactor > 0 )
// ippsDivC_64f_I( (float)(1<<(++tapsfactor)), taps, 6 );
// else if( tapsfactor < 0 )
// ippsMulC_64f_I( (float)(1<<(-(tapsfactor))), taps, 6 );
//
// ippsConvert_64f32s_Sfs ( taps, taps32s, 6, ippRndNear, 0 );
//
// Order of coefficients is:
// B(0),B(1),...,B(order),A(0),A(1),...,A(order)
// A(0) != 0
*/
IPPAPI(IppStatus, ippsIIRInitAlloc32s_16s, (IppsIIRState32s_16s** ppState,
const Ipp32s* pTaps, int order, int tapsFactor, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32s_16s32f, (IppsIIRState32s_16s** ppState,
const Ipp32f* pTaps, int order, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_16sc, (IppsIIRState32sc_16sc** ppState,
const Ipp32sc* pTaps, int order, int tapsFactor, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_16sc32fc, (IppsIIRState32sc_16sc** ppState,
const Ipp32fc* pTaps, int order, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32s_BiQuad_16s, (IppsIIRState32s_16s** ppState,
const Ipp32s* pTaps, int numBq, int tapsFactor, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32s_BiQuad_16s32f, (IppsIIRState32s_16s** ppState,
const Ipp32f* pTaps, int numBq, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_BiQuad_16sc, (IppsIIRState32sc_16sc** ppState,
const Ipp32sc* pTaps, int numBq, int tapsFactor, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_BiQuad_16sc32fc, (IppsIIRState32sc_16sc** ppState,
const Ipp32fc* pTaps, int numBq, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsIIRFree32s_16s, (IppsIIRState32s_16s* pState))
IPPAPI(IppStatus, ippsIIRFree32sc_16sc, (IppsIIRState32sc_16sc* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Work with Delay Line
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRGetDlyLine, ippsIIRSetDlyLine
// Purpose: set and get delay line
// Parameters:
// pState - pointer to IIR filter context
// pDelay - pointer to delay line to be set
// Return:
// ippStsContextMatchErr - wrong context identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsIIRGetDlyLine32s_16s, (const IppsIIRState32s_16s* pState, Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine32s_16s, (IppsIIRState32s_16s* pState, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsIIRGetDlyLine32sc_16sc, (const IppsIIRState32sc_16sc* pState, Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsIIRSetDlyLine32sc_16sc, (IppsIIRState32sc_16sc* pState, const Ipp32sc* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Filtering
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIROne
// Purpose: IIR filter. One sample operation
// Parameters:
// pState - pointer to the filter context
// src - the input sample
// pDstVal - pointer to the output sample
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong context
// ippStsNullPtrErr - pointer(s) to pState or pDstVal is NULL
// ippStsNoErr - otherwise
//
// Note: Don't modify scaleFactor value unless context is changed
*/
IPPAPI(IppStatus, ippsIIROne32s_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState32s_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIROne32sc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, IppsIIRState32sc_16sc* pState, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIR
// Purpose: IIR filter. Vector filtering
// Parameters:
// pState - pointer to the filter context
// pSrc - pointer to input data
// pSrcDst - pointer to input/ouput data
// pDst - pointer to output data
// len - length of the vectors
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong context
// ippStsNullPtrErr - pointer(s) pState or pSrc or pDst is NULL
// ippStsSizeErr - length of the vectors <= 0
// ippStsNoErr - otherwise
//
// Note: Don't modify scaleFactor value unless context is changed
*/
IPPAPI(IppStatus, ippsIIR32s_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int len,
IppsIIRState32s_16s* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR32sc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len,
IppsIIRState32sc_16sc* pState, int scaleFactor))
IPPAPI(IppStatus, ippsIIR32s_16s_ISfs, (Ipp16s* pSrcDst, int len, IppsIIRState32s_16s* pState,
int scaleFactor))
IPPAPI(IppStatus, ippsIIR32sc_16sc_ISfs, (Ipp16sc* pSrcDst, int len, IppsIIRState32sc_16sc* pState,
int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIR_Direct_16s, ippsIIR_Direct_16s_I,
// ippsIIROne_Direct_16s, ippsIIROne_Direct_16s_I,
// ippsIIR_BiQuadDirect_16s, ippsIIR_BiQuadDirect_16s_I,
// ippsIIROne_BiQuadDirect_16s, ippsIIROne_BiQuadDirect_16s_I.
// Purpose: IIR filter with 16s taps. One sample (with suffix One), or vector
// operation, direct (without State structure) form. Suffix "BiQuad"
// means numBq-section filter, else the arbitrary coefficients IIR
// filter.
// Parameters:
// pSrc - pointer to the input array.
// src - input sample in 'One' case.
// pDst - pointer to the output array.
// pDstVal - pointer to the output sample in 'One' case.
// pSrcDst - pointer to the input and output array for the in-place
// operation.
// pSrcDstVal - pointer to the input and output sample for in-place
// operation in 'One' case.
// pTaps - pointer to filter coefficients
// order - arbitrary filter order
// numBq - number biquads of BQ filter
// pDlyLine - pointer to delay line data
// Return: IppStatus
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsIIROrderErr - filter order < 0
// ippStsScaleRangeErr - if A(0) < 0, see "Note..."
// ippStsMemAllocErr - memory allocation error
// ippStsSizeErr - length of the vectors <= 0
// ippStsNoErr - otherwise
//
// Order of the coefficients in the input taps buffer for the arbitrary
// filter:
// B(0),B(1),B(2)..,B(order);
// A(0),A(1),A(2)..,A(order);
// . . .
// Note:
// A(0) >= 0, and means the scale factor (not divisor !) for all the
// other taps.
// Order of the coefficients in the input taps buffer for BiQuad-section
// filter:
// B(0,0),B(0,1),B(0,2),A(0,0),A(0,1),A(0,2);
// B(1,0),B(1,1),B(1,2),A(1,0),A(1,1),A(1,2);
// ........
// Note:
// A(0,0) >= 0, A(1,0) >= 0..., and means the scale factor (not divisor !)
// for all the other taps of each section.
*/
IPPAPI( IppStatus, ippsIIR_Direct_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIR_Direct_16s_I,( Ipp16s* pSrcDst, int len,
const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIROne_Direct_16s,( Ipp16s src, Ipp16s* pDstVal,
const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIROne_Direct_16s_I,( Ipp16s* pSrcDst,
const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIR_BiQuadDirect_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
int len, const Ipp16s* pTaps, int numBq, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIR_BiQuadDirect_16s_I,( Ipp16s* pSrcDst, int len,
const Ipp16s * pTaps, int numBq, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIROne_BiQuadDirect_16s,( Ipp16s src, Ipp16s* pDstVal,
const Ipp16s* pTaps, int numBq, Ipp32s* pDlyLine ))
IPPAPI( IppStatus, ippsIIROne_BiQuadDirect_16s_I,( Ipp16s* pSrcDstVal,
const Ipp16s* pTaps, int numBq, Ipp32s* pDlyLine ))
/* ////////////////////////////////////////////////////////////////////////////
// Initialize IIR state with external memory buffer
//////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsIIRGetStateSize, ippsIIRGetStateSize_BiQuad,
// ippsIIRGetStateSize_BiQuad_DF1_32f,
// ippsIIRInit, ippsIIRInit_BiQuad,
// ippsIIRInit_BiQuad_DF1_32f
//
// Purpose: ippsIIRGetStateSize - calculates the size of the IIR State
// structure;
// ippsIIRInit - initialize IIR state - set taps and delay line
// using external memory buffer;
// Parameters:
// pTaps - pointer to the filter coefficients;
// order - order of the filter;
// numBq - order of the filter;
// pDlyLine - pointer to the delay line values, can be NULL;
// ppState - double pointer to the IIR state created or NULL;
// tapsFactor - scaleFactor for taps (integer version);
// pBufferSize - pointer where to store the calculated IIR State structure
// size (in bytes);
// Return:
// status - status value returned, its value are
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsIIROrderErr - order <= 0 or numBq < 1
// ippStsNoErr - otherwise
*/
/* ******************************** 32s_16s ******************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize32s_16s,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_16sc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32s_BiQuad_16s,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_BiQuad_16sc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit32s_16s,( IppsIIRState32s_16s** ppState,
const Ipp32s* pTaps, int order, int tapsFactor,
const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32sc_16sc,( IppsIIRState32sc_16sc** ppState,
const Ipp32sc* pTaps, int order, int tapsFactor,
const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32s_BiQuad_16s,( IppsIIRState32s_16s** ppState,
const Ipp32s* pTaps, int numBq, int tapsFactor,
const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32sc_BiQuad_16sc,(
IppsIIRState32sc_16sc** ppState, const Ipp32sc* pTaps,
int numBq, int tapsFactor, const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
/* ****************************** 32s_16s32f ******************************* */
IPPAPI( IppStatus, ippsIIRGetStateSize32s_16s32f,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_16sc32fc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32s_BiQuad_16s32f,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_BiQuad_16sc32fc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit32s_16s32f,( IppsIIRState32s_16s** ppState,
const Ipp32f* pTaps, int order, const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32sc_16sc32fc,( IppsIIRState32sc_16sc** ppState,
const Ipp32fc* pTaps, int order,
const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32s_BiQuad_16s32f,( IppsIIRState32s_16s** ppState,
const Ipp32f* pTaps, int numBq,
const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32sc_BiQuad_16sc32fc,(
IppsIIRState32sc_16sc** ppState, const Ipp32fc* pTaps,
int numBq, const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
/* ********************************** 32f ********************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize_32f,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_32fc,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_BiQuad_32f,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_BiQuad_DF1_32f,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_BiQuad_32fc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit_32f,( IppsIIRState_32f** ppState,
const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_32fc,( IppsIIRState_32fc** ppState,
const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_BiQuad_32f,( IppsIIRState_32f** ppState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_BiQuad_DF1_32f,( IppsIIRState_32f** pState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_BiQuad_32fc,( IppsIIRState_32fc** ppState,
const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine, Ipp8u* pBuf ))
/* ******************************** 32f_16s ******************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize32f_16s,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32fc_16sc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32f_BiQuad_16s,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize32fc_BiQuad_16sc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit32f_16s,( IppsIIRState32f_16s** ppState,
const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32fc_16sc,( IppsIIRState32fc_16sc** ppState,
const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32f_BiQuad_16s,( IppsIIRState32f_16s** ppState,
const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit32fc_BiQuad_16sc,( IppsIIRState32fc_16sc** ppState,
const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine, Ipp8u* pBuf ))
/* ********************************** 64f ********************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize_64f,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_64fc,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_BiQuad_64f,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize_BiQuad_64fc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit_64f,( IppsIIRState_64f** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_64fc,( IppsIIRState_64fc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_BiQuad_64f,( IppsIIRState_64f** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit_BiQuad_64fc,( IppsIIRState_64fc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
/* ******************************** 64f_16s ******************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize64f_16s,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_16sc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64f_BiQuad_16s,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_BiQuad_16sc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit64f_16s,( IppsIIRState64f_16s** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_16sc,( IppsIIRState64fc_16sc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64f_BiQuad_16s,( IppsIIRState64f_16s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_BiQuad_16sc,( IppsIIRState64fc_16sc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
/* ******************************** 64f_32s ******************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize64f_32s,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_32sc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64f_BiQuad_32s,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64f_BiQuad_DF1_32s,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_BiQuad_32sc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit64f_32s,( IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_32sc,( IppsIIRState64fc_32sc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64f_BiQuad_32s,( IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64f_BiQuad_DF1_32s,( IppsIIRState64f_32s** ppState,
const Ipp64f* pTaps, int numBq, const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_BiQuad_32sc,( IppsIIRState64fc_32sc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
/* ******************************** 64f_32f ******************************** */
IPPAPI( IppStatus, ippsIIRGetStateSize64f_32f,( int order, int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_32fc,( int order,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64f_BiQuad_32f,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRGetStateSize64fc_BiQuad_32fc,( int numBq,
int *pBufferSize ))
IPPAPI( IppStatus, ippsIIRInit64f_32f,( IppsIIRState64f_32f** ppState,
const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_32fc,( IppsIIRState64fc_32fc** ppState,
const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64f_BiQuad_32f,( IppsIIRState64f_32f** ppState,
const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsIIRInit64fc_BiQuad_32fc,( IppsIIRState64fc_32fc** ppState,
const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine, Ipp8u* pBuf ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRSetTaps
// Purpose: set new IIR taps values to state
// Parameters:
// pTaps - pointer to new IIR taps
// pState - pointer to the IIR filter state
// tapsFactor - scaleFactor for taps (integer version only)
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI( IppStatus, ippsIIRSetTaps_32f,( const Ipp32f *pTaps,
IppsIIRState_32f* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps_32fc,( const Ipp32fc *pTaps,
IppsIIRState_32fc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps32f_16s,( const Ipp32f *pTaps,
IppsIIRState32f_16s* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps32fc_16sc,( const Ipp32fc *pTaps,
IppsIIRState32fc_16sc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps32s_16s,( const Ipp32s *pTaps,
IppsIIRState32s_16s* pState, int tapsFactor ))
IPPAPI( IppStatus, ippsIIRSetTaps32sc_16sc,( const Ipp32sc *pTaps,
IppsIIRState32sc_16sc* pState, int tapsFactor ))
IPPAPI( IppStatus, ippsIIRSetTaps32s_16s32f,( const Ipp32f *pTaps,
IppsIIRState32s_16s* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps32sc_16sc32fc,( const Ipp32fc *pTaps,
IppsIIRState32sc_16sc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps_64f,( const Ipp64f *pTaps,
IppsIIRState_64f* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps_64fc,( const Ipp64fc *pTaps,
IppsIIRState_64fc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64f_32f,( const Ipp64f *pTaps,
IppsIIRState64f_32f* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64fc_32fc,( const Ipp64fc *pTaps,
IppsIIRState64fc_32fc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64f_32s,( const Ipp64f *pTaps,
IppsIIRState64f_32s* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64fc_32sc,( const Ipp64fc *pTaps,
IppsIIRState64fc_32sc* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64f_16s,( const Ipp64f *pTaps,
IppsIIRState64f_16s* pState ))
IPPAPI( IppStatus, ippsIIRSetTaps64fc_16sc,( const Ipp64fc *pTaps,
IppsIIRState64fc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRGenLowpass_64f, ippsIIRGenHighpass_64f
//
// Purpose: This function computes the highpass and lowpass IIR filter coefficients
//
// Parameters:
// rFreq cut off frequency (0 < rFreq < 0.5)
//
// ripple possible ripple in pass band for ippChebyshev1 type of filter
//
// order the order of future filter (1 <= order <= 12)
//
// pTaps pointer to the array which specifies
// the filter coefficients
//
// filterType type of required filter (ippButterworth or ippChebyshev1)
//
//
// Return:
// ippStsNullPtrErr the null pointer to taps[] array pass to function
// ippStsIIRPassbandRippleErr the ripple in passband for Chebyshev1 design is less zero,
// equal to zero or greater than 29
// ippStsFilterFrequencyErr the cut of frequency of filter is less zero, equal to zero
// or greater than 0.5
// ippStsIIRGenOrderErr the order of an IIR filter for design them is less than one
// or greater than 12
// ippStsNoErr otherwise
//
*/
IPPAPI(IppStatus, ippsIIRGenLowpass_64f, ( Ipp64f rFreq, Ipp64f ripple, int order, Ipp64f* pTaps, IppsIIRFilterType filterType))
IPPAPI(IppStatus, ippsIIRGenHighpass_64f,( Ipp64f rFreq, Ipp64f ripple, int order, Ipp64f* pTaps, IppsIIRFilterType filterType))
/* /////////////////////////////////////////////////////////////////////////////
// FIR filters (float and double taps versions)
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct FIRState_32f;
typedef struct FIRState_32f IppsFIRState_32f;
struct FIRState_32fc;
typedef struct FIRState_32fc IppsFIRState_32fc;
struct FIRState32f_16s;
typedef struct FIRState32f_16s IppsFIRState32f_16s;
struct FIRState32fc_16sc;
typedef struct FIRState32fc_16sc IppsFIRState32fc_16sc;
struct FIRState_64f;
typedef struct FIRState_64f IppsFIRState_64f;
struct FIRState_64fc;
typedef struct FIRState_64fc IppsFIRState_64fc;
struct FIRState64f_32f;
typedef struct FIRState64f_32f IppsFIRState64f_32f;
struct FIRState64fc_32fc;
typedef struct FIRState64fc_32fc IppsFIRState64fc_32fc;
struct FIRState64f_32s;
typedef struct FIRState64f_32s IppsFIRState64f_32s;
struct FIRState64fc_32sc;
typedef struct FIRState64fc_32sc IppsFIRState64fc_32sc;
struct FIRState64f_16s;
typedef struct FIRState64f_16s IppsFIRState64f_16s;
struct FIRState64fc_16sc;
typedef struct FIRState64fc_16sc IppsFIRState64fc_16sc;
struct FIRState32s_16s;
typedef struct FIRState32s_16s IppsFIRState32s_16s;
struct FIRState32sc_16sc;
typedef struct FIRState32sc_16sc IppsFIRState32sc_16sc;
struct FIRState_32s;
typedef struct FIRState_32s IppsFIRState_32s;
struct FIRState_16s;
typedef struct FIRState_16s IppsFIRState_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Initialize FIR state
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFIRInitAlloc, ippsFIRMRInitAlloc, ippsFIRFree
// Purpose: create and initialize FIR state - set taps and delay line
// and close it
// Parameters:
// pTaps - pointer to the filter coefficients
// tapsLen - number of coefficients
// pDlyLine - pointer to the delay line values, can be NULL
// state - pointer to the FIR state created or NULL;
// Return:
// status - status value returned, its value are
// ippStsMemAllocErr - memory allocation error
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsFIRLenErr - tapsLen <= 0
// ippStsFIRMRFactorErr - factor <= 0
// ippStsFIRMRPhaseErr - phase < 0 || factor <= phase
// ippStsContextMatchErr - wrong state identifier
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIRInitAlloc_32f, (IppsFIRState_32f** pState,
const Ipp32f* pTaps, int tapsLen, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc_32f, (IppsFIRState_32f** pState,
const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc_32fc, (IppsFIRState_32fc** pState,
const Ipp32fc* pTaps, int tapsLen, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc_32fc, (IppsFIRState_32fc** pState,
const Ipp32fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc32f_16s, (IppsFIRState32f_16s** pState,
const Ipp32f* pTaps, int tapsLen, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32f_16s, (IppsFIRState32f_16s** pState,
const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc32fc_16sc, (IppsFIRState32fc_16sc** pState,
const Ipp32fc* pTaps, int tapsLen, const Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32fc_16sc, (IppsFIRState32fc_16sc** pState,
const Ipp32fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc_64f, (IppsFIRState_64f** pState,
const Ipp64f* pTaps, int tapsLen, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc_64f, (IppsFIRState_64f** pState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc_64fc, (IppsFIRState_64fc** pState,
const Ipp64fc* pTaps, int tapsLen, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc_64fc, (IppsFIRState_64fc** pState,
const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64f_32f, (IppsFIRState64f_32f** pState,
const Ipp64f* pTaps, int tapsLen, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_32f, (IppsFIRState64f_32f** pState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_32fc, (IppsFIRState64fc_32fc** pState,
const Ipp64fc* pTaps, int tapsLen, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_32fc, (IppsFIRState64fc_32fc** pState,
const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64f_32s, (IppsFIRState64f_32s** pState,
const Ipp64f* pTaps, int tapsLen, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_32s, (IppsFIRState64f_32s** pState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_32sc, (IppsFIRState64fc_32sc** pState,
const Ipp64fc* pTaps, int tapsLen, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_32sc, (IppsFIRState64fc_32sc** pState,
const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64f_16s, (IppsFIRState64f_16s** pState,
const Ipp64f* pTaps, int tapsLen, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_16s, (IppsFIRState64f_16s** pState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_16sc, (IppsFIRState64fc_16sc** pState,
const Ipp64fc* pTaps, int tapsLen, const Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_16sc, (IppsFIRState64fc_16sc** pState,
const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRFree_32f, (IppsFIRState_32f* pState))
IPPAPI(IppStatus, ippsFIRFree_32fc, (IppsFIRState_32fc* pState))
IPPAPI(IppStatus, ippsFIRFree32f_16s, (IppsFIRState32f_16s* pState))
IPPAPI(IppStatus, ippsFIRFree32fc_16sc, (IppsFIRState32fc_16sc* pState))
IPPAPI(IppStatus, ippsFIRFree_64f, (IppsFIRState_64f* pState))
IPPAPI(IppStatus, ippsFIRFree_64fc, (IppsFIRState_64fc* pState))
IPPAPI(IppStatus, ippsFIRFree64f_32f, (IppsFIRState64f_32f* pState))
IPPAPI(IppStatus, ippsFIRFree64fc_32fc, (IppsFIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsFIRFree64f_32s, (IppsFIRState64f_32s* pState))
IPPAPI(IppStatus, ippsFIRFree64fc_32sc, (IppsFIRState64fc_32sc* pState))
IPPAPI(IppStatus, ippsFIRFree64f_16s, (IppsFIRState64f_16s* pState))
IPPAPI(IppStatus, ippsFIRFree64fc_16sc, (IppsFIRState64fc_16sc* pState))
/* ////////////////////////////////////////////////////////////////////////////
// Initialize FIR state with external memory buffer
//////////////////////////////////////////////////////////////////////////// */
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsFIRGetStateSize, ippsFIRMRGetStateSize,
// ippsFIRInit, ippsFIRMRInit
// Purpose: ippsFIRGetStateSize - calculates the size of the FIR State
// structure;
// ippsFIRInit - initialize FIR state - set taps and delay line
// using external memory buffer;
// Parameters:
// pTaps - pointer to the filter coefficients;
// tapsLen - number of coefficients;
// pDlyLine - pointer to the delay line values, can be NULL;
// ppState - pointer to the FIR state created or NULL;
// upFactor - multi-rate up factor;
// upPhase - multi-rate up phase;
// downFactor - multi-rate down factor;
// downPhase - multi-rate down phase;
// pStateSize - pointer where to store the calculated FIR State structure
// size (in bytes);
// Return:
// status - status value returned, its value are
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsFIRLenErr - tapsLen <= 0
// ippStsFIRMRFactorErr - factor <= 0
// ippStsFIRMRPhaseErr - phase < 0 || factor <= phase
// ippStsNoErr - otherwise
*/
/* ******************************** 32s_16s ******************************** */
IPPAPI( IppStatus, ippsFIRGetStateSize32s_16s,( int tapsLen, int* pStateSize ))
IPPAPI( IppStatus, ippsFIRInit32s_16s,( IppsFIRState32s_16s** ppState,
const Ipp32s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine,
Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32s_16s,( int tapsLen, int upFactor,
int downFactor, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRMRInit32s_16s,( IppsFIRState32s_16s** ppState,
const Ipp32s *pTaps, int tapsLen, int tapsFactor, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRInit32sc_16sc,( IppsFIRState32sc_16sc** ppState,
const Ipp32sc *pTaps, int tapsLen, int tapsFactor,
const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32sc_16sc,( int tapsLen, int upFactor,
int downFactor, int* pStateSize ))
IPPAPI( IppStatus, ippsFIRMRInit32sc_16sc,( IppsFIRState32sc_16sc** ppState,
const Ipp32sc *pTaps, int tapsLen, int tapsFactor, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRGetStateSize32sc_16sc32fc,( int tapsLen,
int *pStateSize ))
/* ****************************** 32s_16s32f ******************************* */
IPPAPI( IppStatus, ippsFIRGetStateSize32s_16s32f,( int tapsLen,
int* pStateSize ))
IPPAPI( IppStatus, ippsFIRInit32s_16s32f,( IppsFIRState32s_16s** ppState,
const Ipp32f *pTaps, int tapsLen, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32s_16s32f,( int tapsLen, int upFactor,
int downFactor, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRMRInit32s_16s32f,( IppsFIRState32s_16s** ppState,
const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRGetStateSize32sc_16sc,( int tapsLen,
int *pStateSize ))
IPPAPI( IppStatus, ippsFIRInit32sc_16sc32fc,( IppsFIRState32sc_16sc** ppState,
const Ipp32fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32sc_16sc32fc,( int tapsLen,
int upFactor, int downFactor, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRMRInit32sc_16sc32fc,( IppsFIRState32sc_16sc** ppState,
const Ipp32fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
/* ********************************** 32f ********************************** */
IPPAPI( IppStatus, ippsFIRInit_32f,( IppsFIRState_32f** ppState,
const Ipp32f *pTaps, int tapsLen, const Ipp32f *pDlyLine, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRInit_32fc,( IppsFIRState_32fc** ppState,
const Ipp32fc *pTaps, int tapsLen, const Ipp32fc *pDlyLine, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRGetStateSize_32f,( int tapsLen, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRGetStateSize_32fc,( int tapsLen, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit_32f,( IppsFIRState_32f** ppState,
const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32f* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize_32f,( int tapsLen, int upFactor,
int downFactor, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize_32fc,( int tapsLen, int upFactor,
int downFactor, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit_32fc,( IppsFIRState_32fc** ppState,
const Ipp32fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32fc *pDlyLine, Ipp8u* pBuffer ))
/* ******************************** 32f_16s ******************************** */
IPPAPI( IppStatus, ippsFIRGetStateSize32f_16s,( int tapsLen,
int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRInit32f_16s,( IppsFIRState32f_16s** ppState,
const Ipp32f *pTaps, int tapsLen, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRGetStateSize32fc_16sc, ( int tapsLen,
int *pBufferSize ))
IPPAPI(IppStatus, ippsFIRInit32fc_16sc, (IppsFIRState32fc_16sc** ppState,
const Ipp32fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32f_16s,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit32f_16s,( IppsFIRState32f_16s** ppState,
const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize32fc_16sc,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit32fc_16sc,( IppsFIRState32fc_16sc** ppState,
const Ipp32fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
/* ********************************** 64f ********************************** */
IPPAPI( IppStatus, ippsFIRInit_64f,( IppsFIRState_64f** ppState,
const Ipp64f *pTaps, int tapsLen, const Ipp64f *pDlyLine, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRInit_64fc,( IppsFIRState_64fc** ppState,
const Ipp64fc *pTaps, int tapsLen, const Ipp64fc *pDlyLine, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRGetStateSize_64f,( int tapsLen, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRGetStateSize_64fc,( int tapsLen, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit_64f,( IppsFIRState_64f** ppState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp64f* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize_64f,( int tapsLen, int upFactor,
int downFactor, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize_64fc,( int tapsLen, int upFactor,
int downFactor, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit_64fc,( IppsFIRState_64fc** ppState,
const Ipp64fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp64fc *pDlyLine, Ipp8u* pBuffer ))
/* ******************************** 64f_16s ******************************** */
IPPAPI( IppStatus, ippsFIRGetStateSize64f_16s,( int tapsLen,
int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRInit64f_16s,( IppsFIRState64f_16s** ppState,
const Ipp64f *pTaps, int tapsLen, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRGetStateSize64fc_16sc, ( int tapsLen,
int *pBufferSize ))
IPPAPI(IppStatus, ippsFIRInit64fc_16sc, (IppsFIRState64fc_16sc** ppState,
const Ipp64fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64f_16s,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64f_16s,( IppsFIRState64f_16s** ppState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64fc_16sc,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64fc_16sc,( IppsFIRState64fc_16sc** ppState,
const Ipp64fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
/* ******************************** 64f_32s ******************************** */
IPPAPI( IppStatus, ippsFIRGetStateSize64f_32s,( int tapsLen,
int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRInit64f_32s,( IppsFIRState64f_32s** ppState,
const Ipp64f *pTaps, int tapsLen, const Ipp32s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRGetStateSize64fc_32sc, ( int tapsLen,
int *pBufferSize ))
IPPAPI(IppStatus, ippsFIRInit64fc_32sc, (IppsFIRState64fc_32sc** ppState,
const Ipp64fc *pTaps, int tapsLen, const Ipp32sc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64f_32s,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64f_32s,( IppsFIRState64f_32s** ppState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32s* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64fc_32sc,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64fc_32sc,( IppsFIRState64fc_32sc** ppState,
const Ipp64fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32sc *pDlyLine, Ipp8u* pBuffer ))
/* ******************************** 64f_32f ******************************** */
IPPAPI( IppStatus, ippsFIRGetStateSize64f_32f,( int tapsLen,
int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRInit64f_32f,( IppsFIRState64f_32f** ppState,
const Ipp64f *pTaps, int tapsLen, const Ipp32f *pDlyLine, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRGetStateSize64fc_32fc, ( int tapsLen,
int *pBufferSize ))
IPPAPI(IppStatus, ippsFIRInit64fc_32fc, (IppsFIRState64fc_32fc** ppState,
const Ipp64fc *pTaps, int tapsLen, const Ipp32fc *pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64f_32f,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64f_32f,( IppsFIRState64f_32f** ppState,
const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32f* pDlyLine, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize64fc_32fc,( int tapsLen, int upFactor,
int downFactor, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRInit64fc_32fc,( IppsFIRState64fc_32fc** ppState,
const Ipp64fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp32fc *pDlyLine, Ipp8u* pBuffer ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGetTaps
// Purpose: get FIR taps value from state
// Parameters:
// pTaps - pointer to buffer to get FIR taps
// pState - pointer to the FIR filter state
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIRGetTaps_32f, (const IppsFIRState_32f* pState, Ipp32f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps_32fc, (const IppsFIRState_32fc* pState, Ipp32fc* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps32f_16s, (const IppsFIRState32f_16s* pState, Ipp32f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps32fc_16sc, (const IppsFIRState32fc_16sc* pState, Ipp32fc* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps_64f, (const IppsFIRState_64f* pState, Ipp64f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps_64fc, (const IppsFIRState_64fc* pState, Ipp64fc* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64f_32f, (const IppsFIRState64f_32f* pState, Ipp64f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64fc_32fc, (const IppsFIRState64fc_32fc* pState, Ipp64fc* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64f_32s, (const IppsFIRState64f_32s* pState, Ipp64f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64fc_32sc, (const IppsFIRState64fc_32sc* pState, Ipp64fc* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64f_16s, (const IppsFIRState64f_16s* pState, Ipp64f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps64fc_16sc, (const IppsFIRState64fc_16sc* pState, Ipp64fc* pTaps))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGSetTaps
// Purpose: set FIR taps value to state
// Parameters:
// pTaps - pointer to buffer to set FIR taps
// pState - pointer to the FIR filter state
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI( IppStatus, ippsFIRSetTaps_32f,( const Ipp32f *pTaps,
IppsFIRState_32f* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps_32fc,( const Ipp32fc *pTaps,
IppsFIRState_32fc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps32f_16s,( const Ipp32f *pTaps,
IppsFIRState32f_16s* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps32fc_16sc,( const Ipp32fc *pTaps,
IppsFIRState32fc_16sc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps32s_16s,( const Ipp32s *pTaps,
IppsFIRState32s_16s* pState, int tapsFactor ))
IPPAPI( IppStatus, ippsFIRSetTaps32sc_16sc,( const Ipp32sc *pTaps,
IppsFIRState32sc_16sc* pState, int tapsFactor ))
IPPAPI( IppStatus, ippsFIRSetTaps32s_16s32f,( const Ipp32f *pTaps,
IppsFIRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps32sc_16sc32fc,( const Ipp32fc *pTaps,
IppsFIRState32sc_16sc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps_64f,( const Ipp64f *pTaps,
IppsFIRState_64f* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps_64fc,( const Ipp64fc *pTaps,
IppsFIRState_64fc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64f_32f,( const Ipp64f *pTaps,
IppsFIRState64f_32f* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64fc_32fc,( const Ipp64fc *pTaps,
IppsFIRState64fc_32fc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64f_32s,( const Ipp64f *pTaps,
IppsFIRState64f_32s* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64fc_32sc,( const Ipp64fc *pTaps,
IppsFIRState64fc_32sc* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64f_16s,( const Ipp64f *pTaps,
IppsFIRState64f_16s* pState ))
IPPAPI( IppStatus, ippsFIRSetTaps64fc_16sc,( const Ipp64fc *pTaps,
IppsFIRState64fc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// Work with Delay Line
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGetDlyLine, ippsFIRSetDlyLine
// Purpose: set and get delay line
// Parameters:
// pDlyLine - pointer to delay line
// pState - pointer to the filter state
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
// Note: pDlyLine may be NULL
*/
IPPAPI(IppStatus, ippsFIRGetDlyLine_32f, (const IppsFIRState_32f* pState, Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine_32f, (IppsFIRState_32f* pState, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine_32fc, (const IppsFIRState_32fc* pState, Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine_32fc, (IppsFIRState_32fc* pState, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine32f_16s, (const IppsFIRState32f_16s* pState, Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine32f_16s, (IppsFIRState32f_16s* pState, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine32fc_16sc, (const IppsFIRState32fc_16sc* pState, Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine32fc_16sc, (IppsFIRState32fc_16sc* pState, const Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine_64f, (const IppsFIRState_64f* pState, Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine_64f, (IppsFIRState_64f* pState, const Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine_64fc, (const IppsFIRState_64fc* pState, Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine_64fc, (IppsFIRState_64fc* pState, const Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64f_32f, (const IppsFIRState64f_32f* pState, Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64f_32f, (IppsFIRState64f_32f* pState, const Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64fc_32fc, (const IppsFIRState64fc_32fc* pState, Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64fc_32fc, (IppsFIRState64fc_32fc* pState, const Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64f_32s, (const IppsFIRState64f_32s* pState, Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64f_32s, (IppsFIRState64f_32s* pState, const Ipp32s* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64fc_32sc, (const IppsFIRState64fc_32sc* pState, Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64fc_32sc, (IppsFIRState64fc_32sc* pState, const Ipp32sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64f_16s, (const IppsFIRState64f_16s* pState, Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64f_16s, (IppsFIRState64f_16s* pState, const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine64fc_16sc, (const IppsFIRState64fc_16sc* pState, Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine64fc_16sc, (IppsFIRState64fc_16sc* pState, const Ipp16sc* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Filtering
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIROne
// Purpose: FIR filter. One point filtering
// Parameters:
// src - input sample
// pDstVal - output sample
// pState - pointer to the filter state
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIROne_32f, (Ipp32f src, Ipp32f* pDstVal, IppsFIRState_32f* pState))
IPPAPI(IppStatus, ippsFIROne_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsFIRState_32fc* pState))
IPPAPI(IppStatus, ippsFIROne32f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
IppsFIRState32f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal,
IppsFIRState32fc_16sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne_64f, (Ipp64f src, Ipp64f* pDstVal, IppsFIRState_64f* pState))
IPPAPI(IppStatus, ippsFIROne_64fc, (Ipp64fc src, Ipp64fc* pDstVal, IppsFIRState_64fc* pState))
IPPAPI(IppStatus, ippsFIROne64f_32f, (Ipp32f src, Ipp32f* pDstVal, IppsFIRState64f_32f* pState))
IPPAPI(IppStatus, ippsFIROne64fc_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsFIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsFIROne64f_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal,
IppsFIRState64f_32s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal,
IppsFIRState64fc_32sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
IppsFIRState64f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal,
IppsFIRState64fc_16sc* pState, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIR
// Purpose: FIR filter. Vector filtering
// Parameters:
// pSrcDst - pointer to the input/output vector in in-place operation
// pSrc - pointer to the input vector
// pDst - pointer to the output vector
// numIters - number iterations (for single-rate equal length data vector)
// pState - pointer to the filter state
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - numIters is less or equal zero
// ippStsNoErr - otherwise
// Note: for Multi-Rate filtering
// length pSrc = numIters*downFactor
// length pDst = numIters*upFactor
// for inplace functions max this values
*/
IPPAPI(IppStatus, ippsFIR_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters,
IppsFIRState_32f* pState))
IPPAPI(IppStatus, ippsFIR_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters,
IppsFIRState_32fc* pState))
IPPAPI(IppStatus, ippsFIR32f_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
IppsFIRState32f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32fc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
IppsFIRState32fc_16sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR_32f_I, (Ipp32f* pSrcDst, int numIters,
IppsFIRState_32f* pState))
IPPAPI(IppStatus, ippsFIR_32fc_I, (Ipp32fc* pSrcDst, int numIters,
IppsFIRState_32fc* pState))
IPPAPI(IppStatus, ippsFIR32f_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
IppsFIRState32f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32fc_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
IppsFIRState32fc_16sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int numIters,
IppsFIRState_64f* pState))
IPPAPI(IppStatus, ippsFIR_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters,
IppsFIRState_64fc* pState))
IPPAPI(IppStatus, ippsFIR_64f_I, (Ipp64f* pSrcDst, int numIters,
IppsFIRState_64f* pState))
IPPAPI(IppStatus, ippsFIR_64fc_I, (Ipp64fc* pSrcDst, int numIters,
IppsFIRState_64fc* pState))
IPPAPI(IppStatus, ippsFIR64f_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters,
IppsFIRState64f_32f* pState))
IPPAPI(IppStatus, ippsFIR64fc_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters,
IppsFIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsFIR64f_32f_I, (Ipp32f* pSrcDst, int numIters,
IppsFIRState64f_32f* pState))
IPPAPI(IppStatus, ippsFIR64fc_32fc_I, (Ipp32fc* pSrcDst, int numIters,
IppsFIRState64fc_32fc* pState))
IPPAPI(IppStatus, ippsFIR64f_32s_Sfs, (const Ipp32s* pSrc, Ipp32s* pDst, int numIters,
IppsFIRState64f_32s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc* pDst, int numIters,
IppsFIRState64fc_32sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_32s_ISfs, (Ipp32s* pSrcDst, int numIters,
IppsFIRState64f_32s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_32sc_ISfs, (Ipp32sc* pSrcDst, int numIters,
IppsFIRState64fc_32sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
IppsFIRState64f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
IppsFIRState64fc_16sc* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
IppsFIRState64f_16s* pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
IppsFIRState64fc_16sc* pState, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// FIR filters (integer taps version)
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Initialize State
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRInitAlloc, ippsFIRMRInitAlloc, ippsFIRFree
// Purpose: create and initialize FIR state, set taps and delay line
// Parameters:
// pTaps - pointer to the filter coefficients
// tapsLen - number of coefficients
// tapsFactor - scale factor of Ipp32s taps
// pDlyLine - pointer delay line, may be NULL
// state - pointer to the state created or NULL
// Return:
// status - status returned, its values are
// ippStsMemAllocErr - memory allocation error
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsFIRLenErr - tapsLen <= 0
// ippStsFIRMRFactorErr - factor <= 0
// ippStsFIRMRPhaseErr - phase < 0 || factor <= phase
// ippStsNoErr - otherwise
// Notes: pTaps and tapsFactor for Ipp32s calculate as follows
//
// Ipp64f mpy = 1.0;
// Ipp32f pFTaps[tapsLen]; // true values of the coefficients
// Ipp32s pTaps[tapsLen]; // values to be pass to integer FIR
//
// ... calculate coefficients, filling pFTaps ...
//
// max = MAX(abs(pFTaps[i])); for i = 0..tapsLen-1
//
// tapsFactor = 0;
// if (max > IPP_MAX_32S) {
// while (max > IPP_MAX_32S) {
// tapsFactor++;
// max *= 0.5;
// mpy *= 0.5;
// }
// } else {
// while (max < IPP_MAX_32S && tapsFactor > -17) {
// tapsFactor--;
// max += max;
// mpy += mpy;
// }
// tapsFactor++;
// mpy *= 0.5;
// }
//
// for (i = 0; i < tapsLen; i++)
// if (pFTaps[i] < 0)
// pSTaps[i] = (Ipp32s)(mpy*pFTaps[i]-0.5);
// else
// pSTaps[i] = (Ipp32s)(mpy*pFTaps[i]+0.5);
*/
IPPAPI(IppStatus, ippsFIRInitAlloc32s_16s, (IppsFIRState32s_16s** pState,
const Ipp32s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32s_16s, (IppsFIRState32s_16s** pState,
const Ipp32s *pTaps, int tapsLen, int tapsFactor, int upFactor,
int upPhase, int downFactor, int downPhase, const Ipp16s *pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc32s_16s32f, (IppsFIRState32s_16s** pState,
const Ipp32f *pTaps, int tapsLen, const Ipp16s *pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32s_16s32f, (IppsFIRState32s_16s **pState,
const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s *pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc32sc_16sc, (IppsFIRState32sc_16sc** pState,
const Ipp32sc *pTaps, int tapsLen, int tapsFactor, const Ipp16sc *pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32sc_16sc, (IppsFIRState32sc_16sc** pState,
const Ipp32sc *pTaps, int tapsLen, int tapsFactor, int upFactor,
int upPhase, int downFactor, int downPhase, const Ipp16sc *pDlyLine))
IPPAPI(IppStatus, ippsFIRInitAlloc32sc_16sc32fc, (IppsFIRState32sc_16sc** pState,
const Ipp32fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc32sc_16sc32fc, (IppsFIRState32sc_16sc** pState,
const Ipp32fc *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16sc *pDlyLine))
IPPAPI(IppStatus, ippsFIRFree32s_16s, (IppsFIRState32s_16s *pState))
IPPAPI(IppStatus, ippsFIRFree32sc_16sc, (IppsFIRState32sc_16sc *pState))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGetTaps
// Purpose: get FIR taps value from state
// Parameters:
// pTaps - pointer to buffer to get FIR taps
// pState - pointer to the FIR filter state
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIRGetTaps32s_16s, (const IppsFIRState32s_16s* pState,
Ipp32s* pTaps, int* tapsFactor))
IPPAPI(IppStatus, ippsFIRGetTaps32sc_16sc, (const IppsFIRState32sc_16sc* pState,
Ipp32sc* pTaps, int* tapsFactor))
IPPAPI(IppStatus, ippsFIRGetTaps32s_16s32f, (const IppsFIRState32s_16s* pState,
Ipp32f* pTaps))
IPPAPI(IppStatus, ippsFIRGetTaps32sc_16sc32fc, (const IppsFIRState32sc_16sc* pState,
Ipp32fc* pTaps))
/* /////////////////////////////////////////////////////////////////////////////
// Work with Delay Line
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGetDlyLine, ippsFIRSetDlyLine
// Purpose: set and get delay line
// Parameters:
// pDlyLine - pointer to the delay line
// pState - pointer to the FIR filter state
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
// Note: pDlyLine may be NULL
*/
IPPAPI(IppStatus, ippsFIRGetDlyLine32s_16s, (const IppsFIRState32s_16s* pState,
Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine32s_16s, (IppsFIRState32s_16s* pState,
const Ipp16s* pDlyLine))
IPPAPI(IppStatus, ippsFIRGetDlyLine32sc_16sc, (const IppsFIRState32sc_16sc* pState,
Ipp16sc* pDlyLine))
IPPAPI(IppStatus, ippsFIRSetDlyLine32sc_16sc, (IppsFIRState32sc_16sc* pState,
const Ipp16sc* pDlyLine))
/* /////////////////////////////////////////////////////////////////////////////
// Filtering
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIROne, ippsFIROne
// Purpose: FIR filter with integer taps. One sample filtering
// Parameters:
// src - input sample
// pDstVal - pointer to the output sample
// pState - pointer to the FIR filter state
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong state identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIROne32s_16s_Sfs, (Ipp16s src, Ipp16s *pDstVal,
IppsFIRState32s_16s *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32sc_16sc_Sfs, (Ipp16sc src, Ipp16sc *pDstVal,
IppsFIRState32sc_16sc *pState, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIR
// Purpose: FIR filter with integer taps. Vector filtering
// Parameters:
// pSrc - pointer to the input vector
// pDst - pointer to the output vector
// pSrcDst - pointer to input/output vector in in-place operation
// numIters - number iterations (for single-rate equal length data vector)
// pState - pointer to the filter state
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong State identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - numIters <= 0
// ippStsNoErr - otherwise
// Note: for Multi-Rate filtering
// length pSrc = numIters*downFactor
// length pDst = numIters*upFactor
// for inplace functions max this values
*/
IPPAPI(IppStatus, ippsFIR32s_16s_Sfs, (const Ipp16s *pSrc, Ipp16s *pDst,
int numIters, IppsFIRState32s_16s *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32sc_16sc_Sfs, (const Ipp16sc *pSrc, Ipp16sc *pDst,
int numIters, IppsFIRState32sc_16sc *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32s_16s_ISfs, (Ipp16s *pSrcDst, int numIters,
IppsFIRState32s_16s *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32sc_16sc_ISfs, (Ipp16sc *pSrcDst, int numIters,
IppsFIRState32sc_16sc *pState, int scaleFactor ))
IPPAPI( IppStatus, ippsFIRInitAlloc_32s,( IppsFIRState_32s** pState,
const Ipp32s *pTaps, int tapsLen, const Ipp32s *pDlyLine ))
IPPAPI( IppStatus, ippsFIRGetStateSize_32s,( int tapsLen, int* pBufferSize ))
IPPAPI( IppStatus, ippsFIRInit_32s,( IppsFIRState_32s** pState,
const Ipp32s *pTaps, int tapsLen, const Ipp32s *pDlyLine, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsFIRSetTaps_32s,( const Ipp32s *pTaps,
IppsFIRState_32s* pState ))
IPPAPI( IppStatus, ippsFIRGetTaps_32s,( const IppsFIRState_32s* pState,
Ipp32s* pTaps ))
IPPAPI( IppStatus, ippsFIROne_32s_Sfs,( Ipp32s src, Ipp32s *pDstVal,
IppsFIRState_32s *pState, int scaleFactor ))
IPPAPI( IppStatus, ippsFIR_32s_Sfs,( const Ipp32s *pSrc, Ipp32s *pDst,
int numIters, IppsFIRState_32s *pState, int scaleFactor ))
IPPAPI( IppStatus, ippsFIR_32s_ISfs,( Ipp32s *pSrcDst, int numIters,
IppsFIRState_32s *pState, int scaleFactor ))
IPPAPI( IppStatus, ippsFIRFree_32s,( IppsFIRState_32s *pState ))
IPPAPI( IppStatus, ippsFIRGetStateSize_16s,( int tapsLen, int* pStateSize ))
IPPAPI( IppStatus, ippsFIRMRGetStateSize_16s,( int tapsLen, int upFactor,
int downFactor, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRInit_16s,( IppsFIRState_16s** ppState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine,
Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsFIRMRInit_16s,( IppsFIRState_16s** ppState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor, int upPhase,
int downFactor, int downPhase, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRInitAlloc_16s, (IppsFIRState_16s** pState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine))
IPPAPI(IppStatus, ippsFIRMRInitAlloc_16s, (IppsFIRState_16s** pState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor,
int upPhase, int downFactor, int downPhase, const Ipp16s *pDlyLine))
IPPAPI( IppStatus, ippsFIRSetTaps_16s,( const Ipp16s *pTaps,
IppsFIRState_16s* pState, int tapsFactor ))
IPPAPI( IppStatus, ippsFIRGetTaps_16s,( const IppsFIRState_16s* pState,
Ipp16s* pTaps, int* tapsFactor ))
IPPAPI( IppStatus, ippsFIRSetDlyLine_16s,( IppsFIRState_16s *pState,
const Ipp16s *pDlyLine ))
IPPAPI( IppStatus, ippsFIRGetDlyLine_16s,(
const IppsFIRState_16s *pState, Ipp16s *pDlyLine ))
IPPAPI( IppStatus, ippsFIROne_16s_Sfs,( Ipp16s src, Ipp16s *pDstVal,
IppsFIRState_16s *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR_16s_Sfs, (const Ipp16s *pSrc, Ipp16s *pDst,
int numIters, IppsFIRState_16s *pState, int scaleFactor ))
IPPAPI( IppStatus, ippsFIR_16s_ISfs,( Ipp16s *pSrcDst, int numIters,
IppsFIRState_16s *pState, int scaleFactor ))
IPPAPI(IppStatus, ippsFIRFree_16s, (IppsFIRState_16s *pState))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRStream
// Purpose: FIR stream filter with integer taps. Vector filtering
// It does not have delay line.
// Parameters:
// pSrc - pointer to the input vector
// pDst - pointer to the output vector
// numIters - number iterations (for single-rate equal length data vector)
// pState - pointer to the filter state
// scaleFactor - scale factor value
// Return:
// ippStsContextMatchErr - wrong State identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - numIters <= 0
// ippStsNoErr - otherwise
// Note: for Multi-Rate filtering
// length pSrc = numIters*downFactor
// length pDst = numIters*upFactor
// for inplace functions max this values
*/
IPPAPI( IppStatus, ippsFIRStreamGetStateSize_16s,( int tapsLen, int* pStateSize ))
IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_16s,( int tapsLen, int upFactor,
int downFactor, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRStreamInit_16s,( IppsFIRState_16s** pState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, IppRoundMode rndMode, Ipp8u* pBuf ))
IPPAPI( IppStatus, ippsFIRMRStreamInit_16s,( IppsFIRState_16s** ppState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor, int upPhase,
int downFactor, int downPhase, IppRoundMode rndMode, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsFIRStreamInitAlloc_16s, (IppsFIRState_16s** pState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, IppRoundMode rndMode))
IPPAPI(IppStatus, ippsFIRMRStreamInitAlloc_16s, (IppsFIRState_16s** pState,
const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor,
int upPhase, int downFactor, int downPhase, IppRoundMode rndMode))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRStream
// Purpose: FIR stream filter with float taps. Vector filtering
// It does not have delay line.
// Parameters:
// pSrc - pointer to the input vector
// pDst - pointer to the output vector
// numIters - number iterations (for single-rate equal length data vector)
// pState - pointer to the filter state
// scaleFactor - scale factor value// Return:
// ippStsContextMatchErr - wrong State identifier
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - numIters <= 0
// ippStsNoErr - otherwise
// Note: for Multi-Rate filtering
// length pSrc = numIters*downFactor
// length pDst = numIters*upFactor
// for inplace functions max this values
*/
IPPAPI( IppStatus, ippsFIRStreamGetStateSize_32f,( int tapsLen, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_32f,( int tapsLen, int upFactor,
int downFactor, int *pBufferSize ))
IPPAPI( IppStatus, ippsFIRStreamInit_32f,( IppsFIRState_32f** pState,
const Ipp32f *pTaps, int tapsLen, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRMRStreamInit_32f,( IppsFIRState_32f** pState,
const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase, Ipp8u *pBuffer ))
IPPAPI( IppStatus, ippsFIRStreamInitAlloc_32f,( IppsFIRState_32f** pState,
const Ipp32f *pTaps, int tapsLen ))
IPPAPI( IppStatus, ippsFIRMRStreamInitAlloc_32f,( IppsFIRState_32f** pState,
const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
int downFactor, int downPhase ))
/* /////////////////////////////////////////////////////////////////////////////
// FIR LMS filters
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSOne_Direct
// Purpose: direct form of a FIR LMS filter. One point operation.
// Parameters:
// src source signal sample
// refval desired signal sample
// pTapsInv FIR taps coefficient values to be fitted
// tapsLen number of the taps
// pDlyLine pointer to the delay line values
// pDlyIndex pointer to the current index of delay line
// mu adaptation step
// muQ15 adaptation step, integer version
// muQ15 = (int)(mu * (1<<15) + 0.5f)
// pDstVal where write output sample to
// Return:
// ippStsNullPtrErr pointer the the data is null
// ippStsSizeErr the taps length is equal or less zero
// ippStsNoErr otherwise
// Note: adaptation error value has been deleted from the parameter
// list because it can be computed as (refval - dst).
// taps array is inverted, delay line is of double size = tapsLen * 2
*/
IPPAPI(IppStatus, ippsFIRLMSOne_Direct_32f,( Ipp32f src, Ipp32f refval,
Ipp32f* pDstVal, Ipp32f* pTapsInv, int tapsLen, float mu, Ipp32f* pDlyLine,
int* pDlyIndex ))
IPPAPI(IppStatus, ippsFIRLMSOne_Direct32f_16s,( Ipp16s src, Ipp16s refval,
Ipp16s* pDstVal, Ipp32f* pTapsInv, int tapsLen, float mu, Ipp16s* pDlyLine,
int* pDlyIndex ))
IPPAPI(IppStatus, ippsFIRLMSOne_DirectQ15_16s,( Ipp16s src, Ipp16s refval,
Ipp16s* pDstVal, Ipp32s* pTapsInv, int tapsLen, int muQ15, Ipp16s* pDlyLine,
int* pDlyIndex ))
/* context oriented functions */
#if !defined( _OWN_BLDPCS )
struct FIRLMSState_32f;
typedef struct FIRLMSState_32f IppsFIRLMSState_32f;
struct FIRLMSState32f_16s;
typedef struct FIRLMSState32f_16s IppsFIRLMSState32f_16s;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMS
// Purpose: LMS filtering with context use
// Parameters:
// pState pointer to the state
// pSrc pointer to the source signal
// pRef pointer to the desired signal
// pDst pointer to the output signal
// len length of the signals
// mu adaptation step
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsSizeErr the length of signals is equal or less zero
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIRLMS_32f,( const Ipp32f* pSrc, const Ipp32f* pRef,
Ipp32f* pDst, int len, float mu, IppsFIRLMSState_32f* pState ))
IPPAPI(IppStatus, ippsFIRLMS32f_16s,( const Ipp16s* pSrc, const Ipp16s* pRef,
Ipp16s* pDst, int len, float mu, IppsFIRLMSState32f_16s* pStatel ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSInitAlloc, ippsFIRLMSFree
// Purpose: LMS initialization functions
// Parameters:
// pTaps pointer to the taps values. May be null
// tapsLen number of the taps
// pDlyLine pointer to the delay line. May be null
// dlyLineIndex current index value for the delay line
// pState address of pointer to the state returned
// Return:
// ippStsNullPtrErr pointer is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIRLMSInitAlloc_32f,( IppsFIRLMSState_32f** pState,
const Ipp32f* pTaps, int tapsLen, const Ipp32f* pDlyLine, int dlyLineIndex ))
IPPAPI(IppStatus, ippsFIRLMSInitAlloc32f_16s,( IppsFIRLMSState32f_16s** pState,
const Ipp32f* pTaps, int tapsLen, const Ipp16s* pDlyLine, int dlyLineIndex ))
IPPAPI(IppStatus, ippsFIRLMSFree_32f,( IppsFIRLMSState_32f* pState))
IPPAPI(IppStatus, ippsFIRLMSFree32f_16s,( IppsFIRLMSState32f_16s* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSGetTaps
// Purpose: get taps values
// Parameters:
// pstate pointer to the state
// pTaps pointer to the array to store the taps values
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIRLMSGetTaps_32f,( const IppsFIRLMSState_32f* pState,
Ipp32f* pOutTaps ))
IPPAPI(IppStatus, ippsFIRLMSGetTaps32f_16s,( const IppsFIRLMSState32f_16s* pState,
Ipp32f* pOutTaps ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSGetDlyl, ippsFIRLMSSetDlyl
// Purpose: set or get delay line
// Parameters:
// pState pointer to the state structure
// pDlyLine pointer to the delay line of the single size = tapsLen
// pDlyLineIndex pointer to get the current delay line index
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIRLMSGetDlyLine_32f,( const IppsFIRLMSState_32f* pState,
Ipp32f* pDlyLine, int* pDlyLineIndex ))
IPPAPI(IppStatus, ippsFIRLMSGetDlyLine32f_16s,( const IppsFIRLMSState32f_16s* pState,
Ipp16s* pDlyLine, int* pDlyLineIndex ))
IPPAPI(IppStatus, ippsFIRLMSSetDlyLine_32f,( IppsFIRLMSState_32f* pState,
const Ipp32f* pDlyLine, int dlyLineIndex ))
IPPAPI(IppStatus, ippsFIRLMSSetDlyLine32f_16s,( IppsFIRLMSState32f_16s* pState,
const Ipp16s* pDlyLine, int dlyLineIndex ))
/* /////////////////////////////////////////////////////////////////////////////
// FIR LMS MR filters
///////////////////////////////////////////////////////////////////////////// */
/* context oriented functions */
#if !defined( _OWN_BLDPCS )
struct FIRLMSMRState32s_16s;
typedef struct FIRLMSMRState32s_16s IppsFIRLMSMRState32s_16s;
struct FIRLMSMRState32sc_16sc;
typedef struct FIRLMSMRState32sc_16sc IppsFIRLMSMRState32sc_16sc;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMROne, ippsFIRLMSMROneVal
// Purpose: LMS MR filtering with context use
// Parameters:
// val the source signal last value to update delay line
// pDstVal pointer to the output signal value
// pState pointer to the state
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMROne32s_16s,( Ipp32s* pDstVal,
IppsFIRLMSMRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRLMSMROneVal32s_16s,( Ipp16s val, Ipp32s* pDstVal,
IppsFIRLMSMRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRLMSMROne32sc_16sc,( Ipp32sc* pDstVal,
IppsFIRLMSMRState32sc_16sc* pState ))
IPPAPI( IppStatus, ippsFIRLMSMROneVal32sc_16sc,( Ipp16sc val, Ipp32sc* pDstVal,
IppsFIRLMSMRState32sc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRInitAlloc, ippsFIRLMSMRFree
// Purpose: LMS MR initialization functions
// Parameters:
// pState address of pointer to the state returned
// pTaps pointer to the taps values. May be null
// tapsLen number of the taps
// pDlyLine pointer to the delay line. May be null
// dlyLineIndex current index value for the delay line
// dlyStep sample down factor
// updateDly update delay in samples
// mu adaptation step
// Return:
// ippStsNullPtrErr pointer is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRInitAlloc32s_16s,( IppsFIRLMSMRState32s_16s** pState,
const Ipp32s* pTaps, int tapsLen, const Ipp16s* pDlyLine, int dlyLineIndex,
int dlyStep, int updateDly, int mu ))
IPPAPI( IppStatus, ippsFIRLMSMRFree32s_16s,( IppsFIRLMSMRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRLMSMRInitAlloc32sc_16sc,( IppsFIRLMSMRState32sc_16sc** pState,
const Ipp32sc* pTaps, int tapsLen, const Ipp16sc* pDlyLine, int dlyLineIndex,
int dlyStep, int updateDly, int mu ))
IPPAPI( IppStatus, ippsFIRLMSMRFree32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRGetTaps, ippsFIRLMSMRSetTaps,
// ippsFIRLMSMRGetTapsPointer
// Purpose: get & set taps values
// Parameters:
// pState pointer to the state
// pOutTaps pointer to the array to store the taps values
// pInTaps pointer to the taps values. May be null
// pTaps pointer to the state taps values. For direct access
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRSetTaps32s_16s,( IppsFIRLMSMRState32s_16s* pState,
const Ipp32s* pInTaps ))
IPPAPI( IppStatus, ippsFIRLMSMRGetTaps32s_16s,( IppsFIRLMSMRState32s_16s* pState,
Ipp32s* pOutTaps ))
IPPAPI( IppStatus, ippsFIRLMSMRGetTapsPointer32s_16s,( IppsFIRLMSMRState32s_16s* pState,
Ipp32s** pTaps ))
IPPAPI( IppStatus, ippsFIRLMSMRSetTaps32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
const Ipp32sc* pInTaps ))
IPPAPI( IppStatus, ippsFIRLMSMRGetTaps32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
Ipp32sc* pOutTaps ))
IPPAPI( IppStatus, ippsFIRLMSMRGetTapsPointer32sc_16sc,(
IppsFIRLMSMRState32sc_16sc* pState, Ipp32sc** pTaps ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRGetDlyLine, ippsFIRLMSMRSetDlyLine,
// ippsFIRLMSMRGetDlyVal
// Purpose: set or get delay line, or get one delay line value from
// specified position
// Parameters:
// pState pointer to the state structure
// pInDlyLine pointer to the delay line of the (see state definition)
// size = tapsLen * dlyStep + updateDly (may be null)
// pOutDlyLine pointer to the delay line of the (see state definition)
// size = tapsLen * dlyStep + updateDly
// pOutDlyLineIndex pointer to get the current delay line index
// dlyLineIndex current index value for the delay line
// index to get one value posted into delay line "index" iterations ago
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRSetDlyLine32s_16s,( IppsFIRLMSMRState32s_16s* pState,
const Ipp16s* pInDlyLine, int dlyLineIndex ))
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyLine32s_16s,( IppsFIRLMSMRState32s_16s* pState,
Ipp16s* pOutDlyLine, int* pOutDlyIndex ))
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyVal32s_16s,( IppsFIRLMSMRState32s_16s* pState,
Ipp16s* pOutVal, int index ))
IPPAPI( IppStatus, ippsFIRLMSMRSetDlyLine32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
const Ipp16sc* pInDlyLine, int dlyLineIndex ))
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyLine32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
Ipp16sc* pOutDlyLine, int* pOutDlyLineIndex ))
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyVal32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
Ipp16sc* pOutVal, int index ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRPutVal
// Purpose: put one value to the delay line
// Parameters:
// val the source signal last value to update delay line
// pState pointer to the state structure
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRPutVal32s_16s,( Ipp16s val,
IppsFIRLMSMRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRLMSMRPutVal32sc_16sc,( Ipp16sc val,
IppsFIRLMSMRState32sc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRSetMu
// Purpose: set new adaptation step
// Parameters:
// pState pointer to the state structure
// mu new adaptation step
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRSetMu32s_16s,( IppsFIRLMSMRState32s_16s* pState,
const int mu ))
IPPAPI( IppStatus, ippsFIRLMSMRSetMu32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
const int mu ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRLMSMRUpdateTaps
// Purpose: recalculation of taps using Least Mean Square alg
// Parameters:
// ErrVal difference between output and reference signal
// pState pointer to the state structure
// Return:
// ippStsNullPtrErr pointer to the data is null
// ippStsContextMatchErr wrong state identifier
// ippStsNoErr otherwise
*/
IPPAPI( IppStatus, ippsFIRLMSMRUpdateTaps32s_16s,( Ipp32s ErrVal,
IppsFIRLMSMRState32s_16s* pState ))
IPPAPI( IppStatus, ippsFIRLMSMRUpdateTaps32sc_16sc,( Ipp32sc ErrVal,
IppsFIRLMSMRState32sc_16sc* pState ))
/* /////////////////////////////////////////////////////////////////////////////
// FIR filters (direct version)
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIROne_Direct
// Purpose: Directly filters a single sample through a FIR filter.
// Parameters:
// src input sample
// pDstVal pointer to the output sample
// pSrcDstVal pointer to the input and output sample for in-place operation.
// pTaps pointer to the array containing the taps values,
// the number of elements in the array is tapsLen
// tapsLen number of elements in the array containing the taps values.
// tapsFactor scale factor for the taps of Ipp32s data type
// (for integer versions only).
// pDlyLine pointer to the array containing the delay line values,
// the number of elements in the array is 2*tapsLen
// pDlyLineIndex pointer to the current delay line index
// scaleFactor integer scaling factor value
// Return:
// ippStsNullPtrErr pointer(s) to data arrays is(are) NULL
// ippStsFIRLenErr tapsLen is less than or equal to 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIROne_Direct_32f, (Ipp32f src, Ipp32f* pDstVal, const Ipp32f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_32fc, (Ipp32fc src, Ipp32fc* pDstVal, const Ipp32fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_32f_I, (Ipp32f* pSrcDstVal, const Ipp32f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_32fc_I, (Ipp32fc* pSrcDstVal, const Ipp32fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne32f_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, const Ipp32f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32fc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, const Ipp32fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32f_Direct_16s_ISfs, (Ipp16s* pSrcDstVal, const Ipp32f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDstVal, const Ipp32fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne_Direct_64f, (Ipp64f src, Ipp64f* pDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp64f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_64fc, (Ipp64fc src, Ipp64fc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp64fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_64f_I, (Ipp64f* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp64f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne_Direct_64fc_I, (Ipp64fc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp64fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne64f_Direct_32f, (Ipp32f src, Ipp32f* pDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32fc, (Ipp32fc src, Ipp32fc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne64f_Direct_32f_I, (Ipp32f* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32fc_I, (Ipp32fc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIROne64f_Direct_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64f_Direct_32s_ISfs, (Ipp32s* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32sc_ISfs, (Ipp32sc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64f_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64f_Direct_16s_ISfs, (Ipp16s* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne64fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32s_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32sc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32s_Direct_16s_ISfs, (Ipp16s* pSrcDstVal,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIROne32sc_Direct_16sc_ISfs, (Ipp16sc* pSrcDstVal,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
/* ///////////////////////////////////////////////////////////////////////////////////////////
// Names: ippsFIR_Direct
// Purpose: Directly filters a block of samples through a single-rate FIR filter.
// Parameters:
// pSrc pointer to the input array
// pDst pointer to the output array
// pSrcDst pointer to the input and output array for in-place operation.
// numIters number of samples in the input array
// pTaps pointer to the array containing the taps values,
// the number of elements in the array is tapsLen
// tapsLen number of elements in the array containing the taps values.
// tapsFactor scale factor for the taps of Ipp32s data type
// (for integer versions only).
// pDlyLine pointer to the array containing the delay line values,
// the number of elements in the array is 2*tapsLen
// pDlyLineIndex pointer to the current delay line index
// scaleFactor integer scaling factor value
// Return:
// ippStsNullPtrErr pointer(s) to data arrays is(are) NULL
// ippStsFIRLenErr tapsLen is less than or equal to 0
// ippStsSizeErr numIters is less than or equal to 0
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIR_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters, const Ipp32f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_32f_I, (Ipp32f* pSrcDst, int numIters, const Ipp32f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR32f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters, const Ipp32f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters, const Ipp32f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR_Direct_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp64f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp64fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_64f_I, (Ipp64f* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp64f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR_Direct_64fc_I, (Ipp64fc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp64fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR64f_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR64fc_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR64f_Direct_32f_I, (Ipp32f* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp32f* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR64fc_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp32fc* pDlyLine, int* pDlyLineIndex))
IPPAPI(IppStatus, ippsFIR64f_Direct_32s_Sfs, (const Ipp32s* pSrc, Ipp32s* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_Direct_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_Direct_32s_ISfs, (Ipp32s* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_Direct_32sc_ISfs, (Ipp32sc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR64fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32s_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32sc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32s_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPPAPI(IppStatus, ippsFIR32sc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
/* ///////////////////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRMR_Direct
// Purpose: Directly filters a block of samples through a multi-rate FIR filter.
// Parameters:
// pSrc pointer to the input array
// pDst pointer to the output array
// pSrcDst pointer to the input and output array for in-place operation.
// numIters number of iterations in the input array
// pTaps pointer to the array containing the taps values,
// the number of elements in the array is tapsLen
// tapsLen number of elements in the array containing the taps values.
// tapsFactor scale factor for the taps of Ipp32s data type
// (for integer versions only).
// pDlyLine pointer to the array containing the delay line values
// upFactor up-sampling factor
// downFactor down-sampling factor
// upPhase up-sampling phase
// downPhase down-sampling phase
// scaleFactor integer scaling factor value
// Return:
// ippStsNullPtrErr pointer(s) to data arrays is(are) NULL
// ippStsFIRLenErr tapsLen is less than or equal to 0
// ippStsSizeErr numIters is less than or equal to 0
// ippStsFIRMRFactorErr upFactor (downFactor) is less than or equal to 0
// ippStsFIRMRPhaseErr upPhase (downPhase) is negative,
// or less than or equal to upFactor (downFactor).
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsFIRMR_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters,
const Ipp32f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters,
const Ipp32fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_32f_I, (Ipp32f* pSrcDst, int numIters,
const Ipp32f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters,
const Ipp32fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR32f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
const Ipp32f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
const Ipp32fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
const Ipp32f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
const Ipp32fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR_Direct_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_64f_I, (Ipp64f* pSrcDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp64f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR_Direct_64fc_I, (Ipp64fc* pSrcDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp64fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_32f_I, (Ipp32f* pSrcDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32f* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32fc* pDlyLine))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_32s_Sfs, (const Ipp32s* pSrc, Ipp32s* pDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc* pDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_32s_ISfs, (Ipp32s* pSrcDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_32sc_ISfs, (Ipp32sc* pSrcDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp32sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
const Ipp64f* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR64fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
const Ipp64fc* pTaps, int tapsLen, int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32s_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32sc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32s_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
const Ipp32s* pTaps, int tapsLen, int tapsFactor,
int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16s* pDlyLine, int scaleFactor))
IPPAPI(IppStatus, ippsFIRMR32sc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters,
const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
int upFactor,int upPhase, int downFactor, int downPhase,
Ipp16sc* pDlyLine, int scaleFactor))
/* ////////////////////////////////////////////////////////////////////////////
// Names: ippsFIR_Direct_16s_Sfs,
// ippsFIR_Direct_16s_ISfs,
// ippsFIROne_Direct_16s_Sfs,
// ippsFIROne_Direct_16s_ISfs.
// Purpose: Directly filters a block of samples (or one sample in 'One'
// case) through a single-rate FIR filter with fixed point taps
// ( Q15 ).
// Parameters:
// pSrc pointer to the input array.
// src input sample in 'One' case.
// pDst pointer to the output array.
// pDstVal pointer to the output sample in 'One' case.
// pSrcDst pointer to the input and output array for in-place
// operation.
// pSrcDstVal pointer to the input and output sample for in-place
// operation in 'One' case.
// numIters number of samples in the input array.
// pTapsQ15 pointer to the array containing the taps values,
// the number of elements in the array is tapsLen.
// tapsLen number of elements in the array containing the taps
// values.
// pDlyLine pointer to the array containing the delay line values,
// the number of elements in the array is 2 * tapsLen.
// pDlyLineIndex pointer to the current delay line index.
// scaleFactor integer scaling factor value.
// Return:
// ippStsNullPtrErr pointer(s) to data arrays is(are) NULL.
// ippStsFIRLenErr tapsLen is less than or equal to 0.
// ippStsSizeErr sampLen is less than or equal to 0.
// ippStsDlyLineIndexErr current delay line index is greater or equal
// tapsLen, or less than 0.
// ippStsNoErr otherwise.
*/
IPPAPI( IppStatus, ippsFIR_Direct_16s_Sfs,( const Ipp16s* pSrc, Ipp16s* pDst,
int numIters, const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
int* pDlyLineIndex, int scaleFactor ))
IPPAPI( IppStatus, ippsFIR_Direct_16s_ISfs,( Ipp16s* pSrcDst, int numIters,
const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
int* pDlyLineIndex, int scaleFactor ))
IPPAPI( IppStatus, ippsFIROne_Direct_16s_Sfs,( Ipp16s src, Ipp16s* pDstVal,
const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
int* pDlyLineIndex, int scaleFactor ))
IPPAPI( IppStatus, ippsFIROne_Direct_16s_ISfs,( Ipp16s* pSrcDstVal,
const Ipp16s* pTapsQ15, int tapsLen, Ipp16s * pDlyLine,
int* pDlyLineIndex, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRGenLowpass_64f, ippsFIRGenHighpass_64f, ippsFIRGenBandpass_64f
// ippsFIRGenBandstop_64f
// Purpose: This function computes the lowpass FIR filter coefficients
// by windowing of ideal (infinite) filter coefficients segment
//
// Parameters:
// rfreq cut off frequency (0 < rfreq < 0.5)
//
// taps pointer to the array which specifies
// the filter coefficients;
//
// tapsLen the number of taps in taps[] array (tapsLen>=5);
//
// winType the ippWindowType switch variable,
// which specifies the smoothing window type;
//
// doNormal if doNormal=0 the functions calculates
// non-normalized sequence of filter coefficients,
// in other cases the sequence of coefficients
// will be normalized.
// Return:
// ippStsNullPtrErr the null pointer to taps[] array pass to function
// ippStsSizeErr the length of coefficient's array is less than five
// ippStsSizeErr the low or high frequency isn't satisfy
// the condition 0 < rLowFreq < 0.5
// ippStsNoErr otherwise
//
*/
IPPAPI(IppStatus, ippsFIRGenLowpass_64f, (Ipp64f rfreq, Ipp64f* taps, int tapsLen,
IppWinType winType, IppBool doNormal))
IPPAPI(IppStatus, ippsFIRGenHighpass_64f, (Ipp64f rfreq, Ipp64f* taps, int tapsLen,
IppWinType winType, IppBool doNormal))
IPPAPI(IppStatus, ippsFIRGenBandpass_64f, (Ipp64f rLowFreq, Ipp64f rHighFreq, Ipp64f* taps,
int tapsLen, IppWinType winType, IppBool doNormal))
IPPAPI(IppStatus, ippsFIRGenBandstop_64f, (Ipp64f rLowFreq, Ipp64f rHighFreq, Ipp64f* taps,
int tapsLen, IppWinType winType, IppBool doNormal))
/* /////////////////////////////////////////////////////////////////////////////
// Windowing functions
// Note: to create the window coefficients you have to make two calls
// Set(1,x,n) and Win(x,n)
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsWinBartlett
// Parameters:
// pSrcDst pointer to the vector
// len length of the vector, window size
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less 3
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsWinBartlett_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_16sc_I, (Ipp16sc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_32fc_I, (Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBartlett_64fc_I,(Ipp64fc* pSrcDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsWinHann
// Parameters:
// pSrcDst pointer to the vector
// len length of the vector, window size
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less 3
// ippStsNoErr otherwise
// Functionality: 0.5*(1-cos(2*pi*n/(N-1)))
*/
IPPAPI(IppStatus, ippsWinHann_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_16sc_I, (Ipp16sc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_32fc_I, (Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsWinHann_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len))
IPPAPI(IppStatus, ippsWinHann_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsWinHann_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsWinHann_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_64fc_I, (Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHann_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsWinHann_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsWinHamming
// Parameters:
// pSrcDst pointer to the vector
// len length of the vector, window size
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less 3
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsWinHamming_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHamming_16sc_I, (Ipp16sc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHamming_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHamming_32fc_I, (Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHamming_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsWinHamming_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinHamming_64fc_I, (Ipp64fc* pSrcDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsWinBlackman
// Purpose: multiply vector by Blackman windowing function
// Parameters:
// pSrcDst pointer to the vector
// len length of the vector, window size
// alpha adjustable parameter associated with the
// Blackman windowing equation
// alphaQ15 scaled (scale factor 15) version of the alpha
// scaleFactor scale factor of the output signal
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less 3, for Opt it's 4
// ippStsNoErr otherwise
// Notes:
// parameter alpha value
// WinBlackmaStd : -0.16
// WinBlackmaOpt : -0.5 / (1+cos(2*pi/(len-1)))
*/
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s_ISfs, (Ipp16s* pSrcDst, int len,
int alphaQ15, int scaleFactor))
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s_I, (Ipp16s* pSrcDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinBlackmanQ15_16sc_I, (Ipp16sc* pSrcDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinBlackman_16s_I, (Ipp16s* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_16sc_I, (Ipp16sc* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_32f_I, (Ipp32f* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_32fc_I, (Ipp32fc* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinBlackmanQ15_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinBlackman_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackman_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinBlackmanStd_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_16sc_I, (Ipp16sc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_32fc_I, (Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_16s_I, (Ipp16s* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_16sc_I, (Ipp16sc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_32f_I, (Ipp32f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_32fc_I, (Ipp32fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackman_64f_I, (Ipp64f* pSrcDst, int len, double alpha))
IPPAPI(IppStatus, ippsWinBlackman_64fc_I,(Ipp64fc* pSrcDst, int len, double alpha))
IPPAPI(IppStatus, ippsWinBlackman_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len, double alpha))
IPPAPI(IppStatus, ippsWinBlackman_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst, int len, double alpha))
IPPAPI(IppStatus, ippsWinBlackmanStd_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_64fc_I,(Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanStd_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_64f_I, (Ipp64f* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_64fc_I,(Ipp64fc* pSrcDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len))
IPPAPI(IppStatus, ippsWinBlackmanOpt_64fc,(const Ipp64fc* pSrc, Ipp64fc* pDst, int len))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsWinKaiser
// Purpose: multiply vector by Kaiser windowing function
// Parameters:
// pSrcDst pointer to the vector
// len length of the vector, window size
// alpha adjustable parameter associated with the
// Kaiser windowing equation
// alphaQ15 scaled (scale factor 15) version of the alpha
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vector is less 1
// ippStsHugeWinErr window in function is huge
// ippStsNoErr otherwise
*/
IPPAPI(IppStatus, ippsWinKaiser_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_16s_I, (Ipp16s* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiserQ15_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinKaiserQ15_16s_I,(Ipp16s* pSrcDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinKaiser_16sc, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_16sc_I, (Ipp16sc* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiserQ15_16sc,(const Ipp16sc* pSrc, Ipp16sc* pDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinKaiserQ15_16sc_I,(Ipp16sc* pSrcDst, int len, int alphaQ15))
IPPAPI(IppStatus, ippsWinKaiser_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_32f_I, (Ipp32f* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_32fc_I, (Ipp32fc* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_64f_I, (Ipp64f* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_64fc_I, (Ipp64fc* pSrcDst, int len, float alpha))
IPPAPI(IppStatus, ippsWinKaiser_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int len, float alpha))
/* /////////////////////////////////////////////////////////////////////////////
// Median filter
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFilterMedian
// Purpose: filter source data by the Median Filter
// Parameters:
// pSrcDst pointer to the source vector
// pSrc pointer to the source vector
// pDst pointer to the destination vector
// len length of the vector(s)
// maskSize median mask size (odd)
// Return:
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsSizeErr length of the vector(s) is less or equal zero
// ippStsEvenMedianMaskSize median mask size is even warning
// ippStsNoErr otherwise
// Notes:
// - if len is even than len=len-1
// - value of not existed point equals to the last point value,
// for example, x[-1]=x[0] or x[len]=x[len-1]
*/
IPPAPI(IppStatus,ippsFilterMedian_32f_I,(Ipp32f* pSrcDst,int len,int maskSize))
IPPAPI(IppStatus,ippsFilterMedian_64f_I,(Ipp64f* pSrcDst,int len,int maskSize))
IPPAPI(IppStatus,ippsFilterMedian_16s_I,(Ipp16s* pSrcDst,int len,int maskSize))
IPPAPI(IppStatus,ippsFilterMedian_8u_I,(Ipp8u* pSrcDst,int len,int maskSize))
IPPAPI(IppStatus,ippsFilterMedian_32f,(const Ipp32f* pSrc, Ipp32f *pDst,
int len, int maskSize ))
IPPAPI(IppStatus,ippsFilterMedian_64f,(const Ipp64f* pSrc, Ipp64f *pDst,
int len, int maskSize ))
IPPAPI(IppStatus,ippsFilterMedian_16s,(const Ipp16s* pSrc, Ipp16s *pDst,
int len, int maskSize ))
IPPAPI(IppStatus,ippsFilterMedian_8u,(const Ipp8u* pSrc, Ipp8u *pDst,
int len, int maskSize ))
IPPAPI(IppStatus,ippsFilterMedian_32s_I,(Ipp32s* pSrcDst,int len,int maskSize))
IPPAPI(IppStatus,ippsFilterMedian_32s,(const Ipp32s* pSrc, Ipp32s *pDst,
int len, int maskSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Statistic functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsNorm
// Purpose: calculate norm of vector
// Inf - calculate C-norm of vector: n = MAX |src1|
// L1 - calculate L1-norm of vector: n = SUM |src1|
// L2 - calculate L2-norm of vector: n = SQRT(SUM |src1|^2)
// L2Sqr - calculate L2-norm of vector: n = SUM |src1|^2
// Parameters:
// pSrc source data pointer
// len length of vector
// pNorm pointer to result
// scaleFactor scale factor value
// Returns:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of vector is less or equal zero
// Notes:
*/
IPPAPI(IppStatus, ippsNorm_Inf_16s32f, (const Ipp16s* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_Inf_16s32s_Sfs, (const Ipp16s* pSrc, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNorm_Inf_32f, (const Ipp32f* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_Inf_64f, (const Ipp64f* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_16s32f, (const Ipp16s* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_16s32s_Sfs, (const Ipp16s* pSrc, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNorm_L1_32f, (const Ipp32f* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_64f, (const Ipp64f* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L2_16s32f, (const Ipp16s* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_L2_16s32s_Sfs, (const Ipp16s* pSrc, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNorm_L2_32f, (const Ipp32f* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_L2_64f, (const Ipp64f* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_Inf_32fc32f,(const Ipp32fc* pSrc, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNorm_Inf_64fc64f,(const Ipp64fc* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_32fc64f, (const Ipp32fc* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_64fc64f, (const Ipp64fc* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L2_32fc64f, (const Ipp32fc* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L2_64fc64f, (const Ipp64fc* pSrc, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNorm_L1_16s64s_Sfs, (const Ipp16s* pSrc, int len, Ipp64s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNorm_L2Sqr_16s64s_Sfs, (const Ipp16s* pSrc, int len, Ipp64s* pNorm, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsNormDiff
// Purpose: calculate norm of vectors
// Inf - calculate C-norm of vectors: n = MAX |src1-src2|
// L1 - calculate L1-norm of vectors: n = SUM |src1-src2|
// L2 - calculate L2-norm of vectors: n = SQRT(SUM |src1-src2|^2)
// L2Sqr - calculate L2-norm of vectors: n = SUM |src1-src2|^2
// Parameters:
// pSrc1, pSrc2 source data pointers
// len length of vector
// pNorm pointer to result
// scaleFactor scale factor value
// Returns:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of pointers to input or output data are NULL
// ippStsSizeErr The length of vector is less or equal zero
// Notes:
*/
IPPAPI(IppStatus, ippsNormDiff_Inf_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_Inf_16s32s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNormDiff_Inf_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_Inf_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_16s32s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNormDiff_L1_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L2_16s32f, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L2_16s32s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp32s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNormDiff_L2_32f, (const Ipp32f* pSrc1, const Ipp32f* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L2_64f, (const Ipp64f* pSrc1, const Ipp64f* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_Inf_32fc32f,(const Ipp32fc* pSrc1, const Ipp32fc* pSrc2, int len, Ipp32f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_Inf_64fc64f,(const Ipp64fc* pSrc1, const Ipp64fc* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_32fc64f,(const Ipp32fc* pSrc1, const Ipp32fc* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_64fc64f,(const Ipp64fc* pSrc1, const Ipp64fc* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L2_32fc64f,(const Ipp32fc* pSrc1, const Ipp32fc* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L2_64fc64f,(const Ipp64fc* pSrc1, const Ipp64fc* pSrc2, int len, Ipp64f* pNorm))
IPPAPI(IppStatus, ippsNormDiff_L1_16s64s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp64s* pNorm, int scaleFactor))
IPPAPI(IppStatus, ippsNormDiff_L2Sqr_16s64s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2, int len, Ipp64s* pNorm, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Cross Correlation Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCrossCorr_32f, ippsCrossCorr_64f,
// ippsCrossCorr_32fc, ippsCrossCorr_64fc
//
// Purpose: Calculate Cross Correlation
//
// Arguments:
// pSrc1 - pointer to the vector_1 source
// src1Len - vector_1 source length
// pSrc2 - pointer to the vector_2 source
// src2Len - vector_2 source length
// pDst - pointer to the cross correlation
// dstLen - length of cross-correlation
// lowLag - cross-correlation lowest lag
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr either pSrc1 or(and) pSrc2 are NULL
// ippStsSizeErr vector's length is not positive
//
*/
IPPAPI(IppStatus, ippsCrossCorr_32f, (const Ipp32f* pSrc1, int src1Len, const Ipp32f* pSrc2, int src2Len, Ipp32f* pDst, int dstLen, int lowLag))
IPPAPI(IppStatus, ippsCrossCorr_64f, (const Ipp64f* pSrc1, int src1Len, const Ipp64f* pSrc2, int src2Len, Ipp64f* pDst, int dstLen, int lowLag))
IPPAPI(IppStatus, ippsCrossCorr_32fc,(const Ipp32fc* pSrc1, int src1Len, const Ipp32fc* pSrc2, int src2Len, Ipp32fc* pDst, int dstLen, int lowLag))
IPPAPI(IppStatus, ippsCrossCorr_64fc,(const Ipp64fc* pSrc1, int src1Len, const Ipp64fc* pSrc2, int src2Len, Ipp64fc* pDst, int dstLen, int lowLag))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCrossCorr_16s_Sfs
// ippsCrossCorr_16s64s
//
// Purpose: Calculate Cross Correlation and Scale Result (with saturate)
//
// Arguments:
// pSrc1 - pointer to the vector_1 source
// src1Len - vector_1 source length
// pSrc2 - pointer to the vector_2 source
// src2Len - vector_2 source length
// pDst - pointer to the cross correlation
// dstLen - length of cross-correlation
// lowLag - cross-correlation lowest lag
// scaleFactor - scale factor value
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr either pSrc1 or(and) pSrc2 are NULL
// ippStsSizeErr vector's length is not positive
//
*/
IPPAPI(IppStatus, ippsCrossCorr_16s_Sfs, (const Ipp16s* pSrc1, int src1Len, const Ipp16s* pSrc2, int src2Len,
Ipp16s* pDst, int dstLen, int lowLag, int scaleFactor))
IPPAPI(IppStatus, ippsCrossCorr_16s64s, (const Ipp16s* pSrc1, int src1Len, const Ipp16s* pSrc2, int src2Len,
Ipp64s* pDst, int dstLen, int lowLag))
/* /////////////////////////////////////////////////////////////////////////////
// AutoCorrelation Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsAutoCorr_32f, ippsAutoCorr_NormA_32f, ippsAutoCorr_NormB_32f,
// ippsAutoCorr_64f, ippsAutoCorr_NormA_64f, ippsAutoCorr_NormB_64f,
// ippsAutoCorr_32fc, ippsAutoCorr_NormA_32fc, ippsAutoCorr_NormB_32fc,
// ippsAutoCorr_64fc, ippsAutoCorr_NormA_64fc, ippsAutoCorr_NormB_64fc,
//
// Purpose: Calculate the autocorrelation,
// without suffix NormX specifies that the normal autocorrelation to be
// computed;
// suffix NormA specifies that the biased autocorrelation to be
// computed (the resulting values are to be divided on srcLen);
// suffix NormB specifies that the unbiased autocorrelation to be
// computed (the resulting values are to be divided on ( srcLen - n ),
// where "n" means current iteration).
//
// Arguments:
// pSrc - pointer to the source vector
// srcLen - source vector length
// pDst - pointer to the auto-correlation result vector
// dstLen - length of auto-correlation
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr either pSrc or(and) pDst are NULL
// ippStsSizeErr vector's length is not positive
*/
IPPAPI(IppStatus, ippsAutoCorr_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormA_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormB_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormA_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormB_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormA_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormB_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_64fc,( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormA_64fc,( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen ))
IPPAPI(IppStatus, ippsAutoCorr_NormB_64fc,( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsAutoCorr_16s_Sfs,
// ippsAutoCorr_NormA_16s_Sfs,
// ippsAutoCorr_NormB_16s_Sfs
//
// Purpose: Calculate the autocorrelation,
// without suffix NormX specifies that the normal autocorrelation to be
// computed;
// suffix NormA specifies that the biased autocorrelation to be
// computed (the resulting values are to be divided on srcLen);
// suffix NormB specifies that the unbiased autocorrelation to be
// computed (the resulting values are to be divided on ( srcLen - n ),
// where n means current iteration).
//
// Arguments:
// pSrc - pointer to the source vector
// srcLen - source vector length
// pDst - pointer to the auto-correlation result vector
// dstLen - length of auto-correlation
// scaleFactor - scale factor value
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr either pSrc or(and) pDst are NULL
// ippStsSizeErr vector's length is not positive
*/
IPPAPI(IppStatus, ippsAutoCorr_16s_Sfs,( const Ipp16s* pSrc, int srcLen, Ipp16s* pDst,
int dstLen, int scaleFactor ))
IPPAPI(IppStatus, ippsAutoCorr_NormA_16s_Sfs,( const Ipp16s* pSrc, int srcLen, Ipp16s* pDst,
int dstLen, int scaleFactor ))
IPPAPI(IppStatus, ippsAutoCorr_NormB_16s_Sfs,( const Ipp16s* pSrc, int srcLen, Ipp16s* pDst,
int dstLen, int scaleFactor ))
/* /////////////////////////////////////////////////////////////////////////////
// Sampling functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSampleUp
// Purpose: upsampling, i.e. expansion of input vector to get output vector
// by simple adding zeroes between input elements
// Parameters:
// pSrc (in) pointer to the input vector
// pDst (in) pointer to the output vector
// srcLen (in) length of input vector
// dstLen (out) pointer to the length of output vector
// factor (in) the number of output elements, corresponding to one element
// of input vector.
// phase(in-out) pointer to value, that is the position (0, ..., factor-1) of
// element from input vector in the group of factor elements of
// output vector. Out value is ready to continue upsampling with
// the same factor (out = in).
//
// Return:
// ippStsNullPtrErr one or several pointers pSrc, pDst, dstLen or phase
// is NULL
// ippStsSizeErr length of input vector is less or equal zero
// ippStsSampleFactorErr factor <= 0
// ippStsSamplePhaseErr *phase < 0 or *phase >= factor
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsSampleUp_32f, (const Ipp32f* pSrc, int srcLen,
Ipp32f* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleUp_32fc, (const Ipp32fc* pSrc, int srcLen,
Ipp32fc* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleUp_64f, (const Ipp64f* pSrc, int srcLen,
Ipp64f* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleUp_64fc, (const Ipp64fc* pSrc, int srcLen,
Ipp64fc* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleUp_16s, (const Ipp16s* pSrc, int srcLen,
Ipp16s* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleUp_16sc, (const Ipp16sc* pSrc, int srcLen,
Ipp16sc* pDst, int* dstLen,
int factor, int* phase))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsSampleDown
// Purpose: subsampling, i.e. only one of "factor" elements of input vector
// are placed to output vector
// Parameters:
// pSrc (in) pointer to the input vector
// pDst (in) pointer to the output vector
// srcLen (in) length of input vector
// dstLen (out) pointer to the length of output vector
// factor (in) the number of input elements, corresponding to one element
// of output vector.
// phase(in-out) pointer to value, that is the position (0, ..., factor-1) of
// chosen element in the group of "factor" elements. Out value
// of *phase is ready to continue subsampling with the same
// factor.
//
// Return:
// ippStsNullPtrErr one or several pointers pSrc, pDst, dstLen or phase
// is NULL
// ippStsSizeErr length of input vector is less or equal zero
// ippStsSampleFactorErr factor <= 0
// ippStsSamplePhaseErr *phase < 0 or *phase >=factor
// ippStsNoErr otherwise
*/
IPPAPI ( IppStatus, ippsSampleDown_32f, (const Ipp32f* pSrc, int srcLen,
Ipp32f* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleDown_32fc, (const Ipp32fc* pSrc, int srcLen,
Ipp32fc* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleDown_64f, (const Ipp64f* pSrc, int srcLen,
Ipp64f* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleDown_64fc, (const Ipp64fc* pSrc, int srcLen,
Ipp64fc* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleDown_16s, (const Ipp16s* pSrc, int srcLen,
Ipp16s* pDst, int* dstLen,
int factor, int* phase))
IPPAPI ( IppStatus, ippsSampleDown_16sc, (const Ipp16sc* pSrc, int srcLen,
Ipp16sc* pDst, int* dstLen,
int factor, int* phase))
/* ///////////////////////////////////////////////////////////////////////////
// Names: ippsGetVarPointDV_16sc
// Purpose: Fills the array VariantPoint with information about 8
// (if State = 32,64) or 4 (if State = 16) closest to the
// refPoint complex points (stores the indexes in the
// offset table and errors between refPoint and the
// current point)
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Any of the specified pointers is NULL
// Parameters:
// pSrc pointer to the reference point in format 9:7
// pDst pointer to the closest to the reference point left
// and bottom comlexpoint in format 9:7
// pVariantPoint pointer to the array where the information is stored
// pLabel pointer to the labels table
// state number of states of the convolution coder
*/
IPPAPI(IppStatus,ippsGetVarPointDV_16sc,(const Ipp16sc *pSrc,Ipp16sc *pDst,
Ipp16sc *pVariantPoint,const Ipp8u *pLabel,int state))
/* ///////////////////////////////////////////////////////////////////////////
// Names: ippsCalcStatesDV_16sc
// Purpose: Computes possible states of the Viterbi decoder
// Return:
// ippStsNoErr OK
// ippStsNullPtrErr Any of the specified pointers is NULL
// Parameters:
// pPathError pointer to the table of path error metrics
// pNextState pointer to the next state table
// pBranchError pointer to the branch error table
// pCurrentSubsetPoint pointer to the current 4D subset
// pPathTable pointer to the Viterbi path table
// state number of states of the convolution coder
// presentIndex start index in Viterbi Path table
*/
IPPAPI(IppStatus,ippsCalcStatesDV_16sc,(const Ipp16u *pathError,
const Ipp8u *pNextState, Ipp16u *pBranchError,
const Ipp16s *pCurrentSubsetPoint, Ipp16s *pPathTable,
int state,int presentIndex))
/* ///////////////////////////////////////////////////////////////////////////
// Names: ippsBuildSymblTableDV4D_16s
// Purpose: Fills the array with an information of possible 4D symbols
// Return:
// ippStsNoErr OK
// ippStsNullPtrErr Any of the specified pointers is NULL
// Parameters:
// pVariantPoint pointer to the array of possible 2D symbols
// pCurrentSubsetPoint pointer to the current array of 4D symbols
// state number of states of the convolution coder
// bitInversion bit Inversion
*/
IPPAPI(IppStatus,ippsBuildSymblTableDV4D_16sc,(const Ipp16sc *pVariantPoint,
Ipp16sc *pCurrentSubsetPoint,int state,int bitInversion ))
/* ///////////////////////////////////////////////////////////////////////////
// Names: ippsUpdatePathMetricsDV_16u
// Purpose: Searches for the minimum path metric and updates states of the decoder
// Return:
// ippStsNoErr OK
// ippStsNullPtrErr Any of the specified pointers is NULL
// Parameters:
// pBranchError pointer to the branch error table
// pMinPathError pointer to the current minimum path error metric
// pMinSost pointer to the state with minimum path metric
// pPathError pointer to table of path error metrics
// state number of states of the convolution coder
*/
IPPAPI(IppStatus,ippsUpdatePathMetricsDV_16u,(Ipp16u *pBranchError,
Ipp16u *pMinPathError,Ipp8u *pMinSost,Ipp16u *pPathError,int state))
/* /////////////////////////////////////////////////////////////////////////////
// Definitions for Hilbert Functions
///////////////////////////////////////////////////////////////////////////// */
#if !defined( _OWN_BLDPCS )
struct HilbertSpec_32f32fc;
typedef struct HilbertSpec_32f32fc IppsHilbertSpec_32f32fc;
struct HilbertSpec_16s32fc;
typedef struct HilbertSpec_16s32fc IppsHilbertSpec_16s32fc;
struct HilbertSpec_16s16sc;
typedef struct HilbertSpec_16s16sc IppsHilbertSpec_16s16sc;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Hilbert Context Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHilbertInitAlloc_32f32fc, ippsHilbertFree_32f32fc,
// ippsHilbertInitAlloc_16s32fc, ippsHilbertFree_16s32fc,
// ippsHilbertInitAlloc_16s16sc, ippsHilbertFree_16s16sc
// Purpose: create, initialize and delete Hilbert context
// Arguments:
// pSpec - where write pointer to new context
// length - number of samples in Hilbert
// hint - code specific use hints (DFT)
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSpec == NULL
// ippStsSizeErr bad the length value
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI(IppStatus, ippsHilbertInitAlloc_32f32fc, (IppsHilbertSpec_32f32fc **pSpec,
int length, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsHilbertInitAlloc_16s32fc, (IppsHilbertSpec_16s32fc **pSpec,
int length, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsHilbertInitAlloc_16s16sc, (IppsHilbertSpec_16s16sc **pSpec,
int length, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsHilbertFree_32f32fc, (IppsHilbertSpec_32f32fc *pSpec))
IPPAPI(IppStatus, ippsHilbertFree_16s32fc, (IppsHilbertSpec_16s32fc *pSpec))
IPPAPI(IppStatus, ippsHilbertFree_16s16sc, (IppsHilbertSpec_16s16sc *pSpec))
/* /////////////////////////////////////////////////////////////////////////////
// Hilbert Transform Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsHilbert_32f32fc,
// ippsHilbert_16s32fc,
// ippsHilbert_16s16sc_Sfs
// Purpose: compute Hilbert transform of the real signal
// Arguments:
// pSrc - pointer to source real signal
// pDst - pointer to destination complex signal
// pSpec - pointer to Hilbert context
// scaleFactor - scale factor for output signal
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pointer(s) to the data is NULL
// ippStsContextMatchErr bad context identifier
// ippStsMemAllocErr memory allocation error
*/
IPPAPI(IppStatus, ippsHilbert_32f32fc, (const Ipp32f *pSrc, Ipp32fc *pDst,
IppsHilbertSpec_32f32fc *pSpec))
IPPAPI(IppStatus, ippsHilbert_16s32fc, (const Ipp16s *pSrc, Ipp32fc *pDst,
IppsHilbertSpec_16s32fc *pSpec))
IPPAPI(IppStatus, ippsHilbert_16s16sc_Sfs, (const Ipp16s *pSrc, Ipp16sc *pDst,
IppsHilbertSpec_16s16sc *pSpec, int scaleFactor))
#if !defined( _OWN_BLDPCS )
struct FIRSparseState_32f;
typedef struct FIRSparseState_32f IppsFIRSparseState_32f;
struct IIRSparseState_32f;
typedef struct IIRSparseState_32f IppsIIRSparseState_32f;
#endif /* _OWN_BLDPCS */
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsFIRSparseGetStateSize,
// ippsFIRSparseInit
// Purpose: ippsFIRSparseGetStateSize - calculates the size of the FIRSparse
// State structure;
// ippsFIRSparseInit - initialize FIRSparse state - set non-zero taps,
// their positions and delay line using external memory buffer;
// Parameters:
// pNZTaps - pointer to the non-zero filter coefficients;
// pNZTapPos - pointer to the positions of non-zero filter coefficients;
// nzTapsLen - number of non-zero coefficients;
// pDlyLine - pointer to the delay line values, can be NULL;
// pState - pointer to the FIRSparse state created or NULL;
// order - order of FIRSparse filter
// pStateSize - pointer where to store the calculated FIRSparse State
// structuresize (in bytes);
// Return:
// status - status value returned, its value are
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsFIRLenErr - nzTapsLen <= 0
// ippStsSparseErr - non-zero tap positions are not in ascending order,
// negative or repeated.
// ippStsNoErr - otherwise
*/
IPPAPI( IppStatus, ippsFIRSparseGetStateSize_32f,( int nzTapsLen,
int order, int *pStateSize ))
IPPAPI( IppStatus, ippsFIRSparseInit_32f,( IppsFIRSparseState_32f** pState,
const Ipp32f *pNZTaps, const Ipp32s* pNZTapPos, int nzTapsLen,
const Ipp32f *pDlyLine, Ipp8u *pBuffer ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsIIRSparseGetStateSize,
// ippsIIRSparseInit
// Purpose: ippsIIRSparseGetStateSize - calculates the size of the
// IIRSparse State structure;
// ippsIIRSparseInit - initialize IIRSparse state - set non-zero taps,
// their positions and delay line using external memory buffer;
// Parameters:
// pNZTaps - pointer to the non-zero filter coefficients;
// pNZTapPos - pointer to the positions of non-zero filter coefficients;
// nzTapsLen1,
// nzTapsLen2 - number of non-zero coefficients according to the IIRSparseformula;
// pDlyLine - pointer to the delay line values, can be NULL;
// pState - pointer to the IIR state created or NULL;
// pStateSize - pointer where to store the calculated IIR State structure
// size (in bytes);
// Return:
// status - status value returned, its value are
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsIIROrderErr - nzTapsLen1 <= 0 or nzTapsLen2 < 0
// ippStsSparseErr - non-zero tap positions are not in ascending order,
// negative or repeated.
// ippStsNoErr - otherwise
*/
IPPAPI( IppStatus, ippsIIRSparseGetStateSize_32f,( int nzTapsLen1, int nzTapsLen2,
int order1, int order2, int *pStateSize ))
IPPAPI( IppStatus, ippsIIRSparseInit_32f,( IppsIIRSparseState_32f** pState,
const Ipp32f* pNZTaps, const Ipp32s* pNZTapPos, int nzTapsLen1,
int nzTapsLen2, const Ipp32f* pDlyLine, Ipp8u* pBuf ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsFIRSparse
// Purpose: FIRSparse filter with float taps. Vector filtering
// Parameters:
// pSrc - pointer to the input vector
// pDst - pointer to the output vector
// len - length data vector
// pState - pointer to the filter state
// Return:
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - length of the vectors <= 0
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsFIRSparse_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len,
IppsFIRSparseState_32f* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsIIRSparse
// Purpose: IIRSparse filter with float taps. Vector filtering
// Parameters:
// pSrc - pointer to input vector
// pDst - pointer to output vector
// len - length of the vectors
// pState - pointer to the filter state
// Return:
// ippStsNullPtrErr - pointer(s) to the data is NULL
// ippStsSizeErr - length of the vectors <= 0
// ippStsNoErr - otherwise
*/
IPPAPI(IppStatus, ippsIIRSparse_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int len,
IppsIIRSparseState_32f* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsAddProductC
// Purpose: multiplies elements of of a vector by a constant and adds product to
// the accumulator vector
// Parameters:
// pSrc pointer to the source vector
// val constant value
// pSrcDst pointer to the source/destination (accumulator) vector
// len length of the vectors
// Return:
// ippStsNullPtrErr pointer to the vector is NULL
// ippStsSizeErr length of the vectors is less or equal zero
// ippStsNoErr otherwise
//
// Notes: pSrcDst[n] = pSrcDst[n] + pSrc[n] * val, n=0,1,2,..len-1.
*/
IPPAPI(IppStatus, ippsAddProductC_32f, ( const Ipp32f* pSrc, const Ipp32f val,
Ipp32f* pSrcDst, int len ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippsSumWindow_8u32f ippsSumWindow_16s32f
// Purpose:
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsMaskSizeErr maskSize has a field with zero, or negative value
// Arguments:
// pSrc Pointer to the source vector
// pDst Pointer to the destination vector
// maskSize Size of the mask in pixels
*/
IPPAPI(IppStatus,ippsSumWindow_8u32f ,(const Ipp8u* pSrc,Ipp32f* pDst,int len, int maskSize ))
IPPAPI(IppStatus,ippsSumWindow_16s32f,(const Ipp16s* pSrc,Ipp32f* pDst,int len, int maskSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippsCountInRange_32s
// Purpose: Computes the number of vector elements falling within the specified range.
// Return:
// ippStsNoErr No errors, it's OK
// ippStsNullPtrErr Either pSrc or pCounts equals to zero.
// ippStsLengthErr The vector's length is less than or equals to zero.
// Arguments:
// pSrc A pointer to the source vector.
// len Number of the vector elements.
// pCounts A pointer to the output result.
// lowerBound The upper boundary of the range.
// uppreBound The lower boundary of the range.
*/
IPPAPI( IppStatus, ippsCountInRange_32s, ( const Ipp32s* pSrc, int len, int* pCounts,
Ipp32s lowerBound, Ipp32s upperBound ) )
/*
// Purpose: Creates ramp vector
//
// Parameters:
// pDst A pointer to the destination vector
// len Vector's length
// offset Offset value
// slope Slope coefficient
//
// Return:
// ippStsNoErr No error
// ippStsNullPtrErr pDst pointer is NULL
// ippStsBadSizeErr Vector's length is less or equal zero
// ippStsNoErr No error
//
// Notes: Dst[n] = offset + slope * n
//
*/
IPPAPI(IppStatus, ippsVectorSlope_8u, ( Ipp8u* pDst, int len, Ipp32f offset, Ipp32f slope ))
IPPAPI(IppStatus, ippsVectorSlope_8s, ( Ipp8s* pDst, int len, Ipp32f offset, Ipp32f slope ))
IPPAPI(IppStatus, ippsVectorSlope_16u, ( Ipp16u* pDst, int len, Ipp32f offset, Ipp32f slope ))
IPPAPI(IppStatus, ippsVectorSlope_16s, ( Ipp16s* pDst, int len, Ipp32f offset, Ipp32f slope ))
IPPAPI(IppStatus, ippsVectorSlope_32u, ( Ipp32u* pDst, int len, Ipp64f offset, Ipp64f slope ))
IPPAPI(IppStatus, ippsVectorSlope_32s, ( Ipp32s* pDst, int len, Ipp64f offset, Ipp64f slope ))
IPPAPI(IppStatus, ippsVectorSlope_32f, ( Ipp32f* pDst, int len, Ipp32f offset, Ipp32f slope ))
IPPAPI(IppStatus, ippsVectorSlope_64f, ( Ipp64f* pDst, int len, Ipp64f offset, Ipp64f slope ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippsDiv_Round_8u_Sfs
// ippsDiv_Round_16u_Sfs
// ippsDiv_Round_16s_Sfs
// ippsDiv_Round_8u_ISfs
// ippsDiv_Round_16u_ISfs
// ippsDiv_Round_16s_ISfs
//
//
// Purpose: divide every element of the source vector by the scalar value
// or by corresponding element of the second source vector and
// round to zero, near or financial
// Arguments:
// val the divisor value
// pSrc pointer to the divisor source vector
// pSrc1 pointer to the divisor source vector
// pSrc2 pointer to the dividend source vector
// pDst pointer to the destination vector
// pSrcDst pointer to the source/destination vector
// len vector's length, number of items
// rndMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
// scaleFactor scale factor parameter value
// Return:
// ippStsNullPtrErr pointer(s) to the data vector is NULL
// ippStsSizeErr length of the vector is less or equal zero
// ippStsDivByZeroErr the scalar divisor value is zero
// ippStsDivByZero Warning status if an element of divisor vector is
// zero. If the dividend is zero than result is
// NaN, if the dividend is not zero than result
// is Infinity with correspondent sign. The
// execution is not aborted. For the integer operation
// zero instead of NaN and the corresponding bound
// values instead of Infinity
// ippStsRoundModeNotSupportedErr Unsupported round mode
// ippStsNoErr otherwise
// Note:
// DivC(v,X,Y) : Y[n] = X[n] / v
// DivC(v,X) : X[n] = X[n] / v
// Div(X,Y) : Y[n] = Y[n] / X[n]
// Div(X,Y,Z) : Z[n] = Y[n] / X[n]
*/
IPPAPI(IppStatus, ippsDiv_Round_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
Ipp8u* pDst, int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_Round_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
Ipp16s* pDst, int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_Round_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
Ipp16u* pDst, int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_Round_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_Round_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
int len, IppRoundMode rndMode, int scaleFactor))
IPPAPI(IppStatus, ippsDiv_Round_16u_ISfs, (const Ipp16u* pSrc, Ipp16u* pSrcDst,
int len, IppRoundMode rndMode, int scaleFactor))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippsDemodulateFM_CToR_16s
// Purpose: FM demodulate
// Return:
// IPP_NO_ERR Ok
// IPP_NULL_PTR_ERR Some of pointers are NULL
// IPP_BADSIZE_ERR The length of the array is less or equal zero
// Parameters:
// pSrcRe pointer to input vector of Real data
// pSrcIm pointer to input vector of Image data
// pDst pointer to output vector
// len a length of the array
// pDlyPoint pointer to earlier data
*/
IPPAPI(IppStatus, ippsDemodulateFM_CToR_16s,( const Ipp16s* pSrcRe,
const Ipp16s *pSrcIm, Ipp16s *pDst, int len, Ipp16sc *pDlyPoint ))
/* ///////////////////////////////////////////////////////////////////////////
// Name: ippsCauchy_32f_I, ippsCauchyD_32f_I, ippsCauchyDD2_32f_I
//
// Purpose: Compute Cauchy robust error function or its 1st, 2nd derivatives
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr Some of the pointers are NULL's
// ippStsSizeErr Length is negative
// ippStsOutOfRangeErr C is negative
//
// Arguments:
// pSrcDst The input/output array of function arguments/values.
// pD2F The array of values of the 2nd derivative.
// len Length of srcdst and d2fval
// C Cauchy function parameter
*/
IPPAPI(IppStatus, ippsCauchy_32f_I, (Ipp32f* pSrcDst, int len, Ipp32f C))
IPPAPI(IppStatus, ippsCauchyD_32f_I, (Ipp32f* pSrcDst, int len, Ipp32f C))
IPPAPI(IppStatus, ippsCauchyDD2_32f_I, (Ipp32f* pSrcDst, Ipp32f* pD2F, int len, Ipp32f C))
/* ///////////////////////////////////////////////////////////////////////////
// Name: ippsZeroCrossing_*
// Purpose: Counts the zero-cross measure for the input signal.
//
// Parameters:
// pSrc Pointer to the input signal [len].
// len Number of elements in the input signal.
// pValZCR Pointer to the result value.
// zcType Zero crossing measure type.
// Return:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when the pSrc or pRes pointer is null.
// ippStsRangeErr Indicates an error when zcType is not equal to
// ippZCR, ippZCXor or ippZCC
*/
IPPAPI(IppStatus, ippsZeroCrossing_16s32f,(const Ipp16s* pSrc, Ipp32u len,
Ipp32f* pValZCR, IppsZCType zcType))
IPPAPI(IppStatus, ippsZeroCrossing_32f, (const Ipp32f* pSrc, Ipp32u len,
Ipp32f* pValZCR, IppsZCType zcType))
/* /////////////////////////////////////////////////////////////////////////////
// The library was generated by Spiral, developed at Carnegie Mellon
// University, http://www.spiral.net
*/
/*
/////////////////////////////////////////////////////////////////////////////
// Name: ippgenGetLibVersion
// Purpose: getting of the library version
// Returns: the structure of information about version of ippGEN library
// Parameters:
//
// Notes: not necessary to release the returned structure
*/
IPPAPI( const IppLibraryVersion*, ippgenGetLibVersion, (void) )
#if !defined( _OWN_BLDPCS )
typedef void ippgDCT4Spec_32f;
typedef void ippgDCT4Spec_64f;
#endif /* _OWN_BLDPCS */
IPPAPI(IppStatus, ippgDCT4Free_64f, (ippgDCT4Spec_64f *spec) )
IPPAPI(IppStatus, ippgDCT4GetSize_64f, (int len, int *pSize))
IPPAPI(IppStatus, ippgDCT4Init_64f, (ippgDCT4Spec_64f **pSpec, int len, Ipp8u *pMem) )
IPPAPI(IppStatus, ippgDCT4InitAlloc_64f, (ippgDCT4Spec_64f **pSpec, int len) )
IPPAPI(IppStatus, ippgDCT4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, const ippgDCT4Spec_64f *spec) )
IPPAPI(IppStatus, ippgDCT4Free_32f, (ippgDCT4Spec_32f *spec) )
IPPAPI(IppStatus, ippgDCT4GetSize_32f, (int len, int *pSize))
IPPAPI(IppStatus, ippgDCT4Init_32f, (ippgDCT4Spec_32f **pSpec, int len, Ipp8u *pMem) )
IPPAPI(IppStatus, ippgDCT4InitAlloc_32f, (ippgDCT4Spec_32f **pSpec, int len) )
IPPAPI(IppStatus, ippgDCT4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, const ippgDCT4Spec_32f *spec) )
/* /////////////////////////////////////////////////////////////////////////////
// Walsh Hadamard transforms of fixed size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippgWHT
// Purpose: compute Walsh Hadamard transform of a signal
// Note: Walsh Hadamard transform is involutary (self-inverse)
// Normalization choices: IPP_NODIV_BY_ANY, IPP_DIV_BY_SQRTN,
// IPP_DIV_FWD_BY_N is same as IPP_DIV_INV_BY_N
// Arguments:
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// order - number of samples in the input signal pSrc is 2^order
// valid values for order are [ 1 .. 13 ]
// flag - normalization flag
//
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI(IppStatus, ippgWHTGetBufferSize_32f, (int order, Ipp32u *pBufferSize) )
IPPAPI(IppStatus, ippgWHTGetBufferSize_64f, (int order, Ipp32u *pBufferSize) )
IPPAPI(IppStatus, ippgWHT_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int order, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int order, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_1_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_1_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag, Ipp8u *pBuffer) )
IPPAPI(IppStatus, ippgWHT_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag, Ipp8u *pBuffer) )
/* /////////////////////////////////////////////////////////////////////////////
// DFT Complex Transforms of fixed size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippgDFTFwd_CToC, ippsDFTInv_CToC
// Purpose: compute forward and inverse DFT of a complex signal
// Normalization choices: IPP_NODIV_BY_ANY, IPP_DIV_BY_SQRTN,
// IPP_DIV_FWD_BY_N, IPP_DIV_INV_BY_N
// Arguments:
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// length - number of samples in the input signal pSrc
// valid values for length are [ 2 .. 64 ]
// flag - normalization flag
//
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI(IppStatus, ippgDFTFwd_CToC_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_2_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_2_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_2_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_2_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_3_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_3_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_3_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_3_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_4_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_4_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_4_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_4_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_5_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_5_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_5_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_5_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_6_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_6_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_6_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_6_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_7_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_7_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_7_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_7_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_8_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_8_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_8_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_8_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_9_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_9_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_9_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_9_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_10_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_10_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_10_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_10_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_11_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_11_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_11_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_11_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_12_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_12_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_12_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_12_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_13_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_13_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_13_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_13_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_14_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_14_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_14_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_14_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_15_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_15_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_15_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_15_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_16_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_16_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_16_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_16_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_17_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_17_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_17_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_17_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_18_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_18_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_18_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_18_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_19_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_19_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_19_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_19_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_20_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_20_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_20_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_20_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_21_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_21_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_21_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_21_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_22_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_22_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_22_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_22_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_23_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_23_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_23_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_23_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_24_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_24_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_24_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_24_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_25_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_25_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_25_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_25_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_26_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_26_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_26_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_26_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_27_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_27_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_27_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_27_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_28_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_28_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_28_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_28_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_29_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_29_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_29_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_29_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_30_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_30_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_30_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_30_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_31_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_31_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_31_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_31_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_32_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_32_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_32_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_32_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_33_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_33_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_33_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_33_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_34_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_34_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_34_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_34_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_35_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_35_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_35_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_35_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_36_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_36_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_36_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_36_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_37_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_37_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_37_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_37_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_38_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_38_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_38_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_38_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_39_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_39_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_39_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_39_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_40_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_40_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_40_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_40_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_41_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_41_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_41_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_41_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_42_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_42_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_42_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_42_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_43_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_43_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_43_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_43_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_44_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_44_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_44_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_44_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_45_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_45_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_45_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_45_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_46_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_46_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_46_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_46_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_47_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_47_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_47_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_47_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_48_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_48_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_48_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_48_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_49_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_49_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_49_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_49_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_50_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_50_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_50_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_50_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_51_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_51_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_51_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_51_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_52_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_52_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_52_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_52_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_53_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_53_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_53_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_53_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_54_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_54_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_54_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_54_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_55_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_55_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_55_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_55_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_56_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_56_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_56_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_56_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_57_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_57_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_57_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_57_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_58_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_58_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_58_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_58_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_59_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_59_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_59_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_59_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_60_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_60_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_60_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_60_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_61_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_61_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_61_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_61_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_62_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_62_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_62_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_62_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_63_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_63_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_63_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_63_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_64_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_CToC_64_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_64_32fc, (const Ipp32fc *pSrc, Ipp32fc *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CToC_64_64fc, (const Ipp64fc *pSrc, Ipp64fc *pDst, int flag) )
/* /////////////////////////////////////////////////////////////////////////////
// DFT Real Transforms of fixed size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippgDFTFwd_RToCCS, ippgDFTFwd_RToPack, ippgDFTFwd_RToPerm,
// ippsDFTInv_CCSToR, ippgDFTInv_PackToR, ippgDFTInv_PermToR,
// Purpose: compute forward and inverse DFT of a real signal
// Normalization choices: IPP_NODIV_BY_ANY, IPP_DIV_BY_SQRTN,
// IPP_DIV_FWD_BY_N, IPP_DIV_INV_BY_N
// Arguments:
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// length - number of samples in the input signal pSrc
// valid values for length are [ 2 .. 64 ]
// flag - normalization flag
//
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI(IppStatus, ippgDFTFwd_RToPack_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPack_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToPerm_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTFwd_RToCCS_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PackToR_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_PermToR_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgDFTInv_CCSToR_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
/* /////////////////////////////////////////////////////////////////////////////
// Discrete Hartley Transforms of fixed size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippgHartley
// Purpose: compute Hartley transform of a real signal
// Note: Hartley transform is involutary (self-inverse)
// Normalization choices: IPP_NODIV_BY_ANY, IPP_DIV_BY_SQRTN,
// IPP_DIV_FWD_BY_N is same as IPP_DIV_INV_BY_N
// Arguments:
// pSrc - pointer to source complex signal
// pDst - pointer to destination complex signal
// length - number of samples in the input signal pSrc
// valid values for length are [ 2 .. 64 ]
// flag - normalization flag
//
// Return:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or
// ippStsFftFlagErr bad the normalization flag value
*/
IPPAPI(IppStatus, ippgHartley_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgHartley_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int length, int flag) )
IPPAPI(IppStatus, ippgHartley_2_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_2_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_3_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_3_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_4_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_4_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_5_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_5_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_6_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_6_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_7_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_7_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_8_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_8_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_9_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_9_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_10_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_10_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_11_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_11_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_12_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_12_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_13_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_13_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_14_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_14_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_15_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_15_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_16_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_16_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_17_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_17_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_18_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_18_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_19_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_19_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_20_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_20_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_21_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_21_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_22_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_22_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_23_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_23_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_24_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_24_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_25_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_25_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_26_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_26_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_27_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_27_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_28_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_28_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_29_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_29_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_30_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_30_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_31_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_31_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_32_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_32_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_33_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_33_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_34_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_34_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_35_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_35_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_36_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_36_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_37_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_37_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_38_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_38_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_39_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_39_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_40_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_40_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_41_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_41_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_42_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_42_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_43_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_43_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_44_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_44_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_45_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_45_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_46_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_46_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_47_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_47_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_48_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_48_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_49_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_49_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_50_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_50_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_51_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_51_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_52_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_52_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_53_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_53_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_54_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_54_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_55_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_55_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_56_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_56_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_57_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_57_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_58_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_58_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_59_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_59_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_60_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_60_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_61_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_61_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_62_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_62_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_63_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_63_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_64_32f, (const Ipp32f *pSrc, Ipp32f *pDst, int flag) )
IPPAPI(IppStatus, ippgHartley_64_64f, (const Ipp64f *pSrc, Ipp64f *pDst, int flag) )
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#ifdef __cplusplus
}
#endif
#endif /* __IPPS_H__ */
/* ////////////////////////// End of file "ipps.h" ////////////////////////// */