/* ////////////////////////////////// "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-2014 Intel Corporation. All Rights Reserved.
//
//                 Intel(R) Integrated Performance Primitives
//                      Signal Processing (ippSP)
//
*/

#if !defined( __IPPS_H__ ) || defined( _OWN_BLDPCS )
#define __IPPS_H__


#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
  #define _IPP_STDCALL_CDECL
  #undef __stdcall
#endif


#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif


#if !defined( _IPP_NO_DEFAULT_LIB )
  #if defined( _IPP_SEQUENTIAL_DYNAMIC )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "ipps" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "ippcore" )
  #elif defined( _IPP_SEQUENTIAL_STATIC )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "ippsmt" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "ippvmmt" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "ippcoremt" )
  #elif defined( _IPP_PARALLEL_DYNAMIC )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "threaded/ipps" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "threaded/ippcore" )
  #elif defined( _IPP_PARALLEL_STATIC )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "threaded/ippsmt" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "threaded/ippvmmt" )
    #pragma comment( lib, __FILE__ "/../../lib/" _INTEL_PLATFORM "threaded/ippcoremt" )
  #endif
#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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsPackBits_32u8u,( const Ipp32u* pSrcBit,
                                        const int*    pSrcBits,
                                              int     srcLen,
                                              Ipp8u*  pDst,
                                              int     dstBitOffset,
                                              int*    pDstLenBit ))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCopy_1u
//              ippsCopyLE_1u
//              ippsCopyBE_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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsCopyLE_1u function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCopy_1u,
      ( const Ipp8u* pSrc, int srcBitOffset, Ipp8u* pDst, int dstBitOffset, int len ))
IPPAPI(IppStatus, ippsCopyLE_1u,
      ( const Ipp8u* pSrc, int srcBitOffset, Ipp8u* pDst, int dstBitOffset, int len ))
IPPAPI(IppStatus, ippsCopyBE_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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandUniform_16s function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandUniform_Direct_16s, (Ipp16s* pDst, int len, Ipp16s low, Ipp16s high,
                                               unsigned int* pSeed))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandUniform_32f function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandUniform_Direct_32f, (Ipp32f* pDst, int len, Ipp32f low, Ipp32f high,
                                               unsigned int* pSeed))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandUniform_64 function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandGauss_16s function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandGauss_Direct_16s, (Ipp16s* pDst, int len, Ipp16s mean, Ipp16s stdev,
                                            unsigned int* pSeed))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandGauss_32f function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandGauss_Direct_32f, (Ipp32f* pDst, int len, Ipp32f mean, Ipp32f stdev,
                                            unsigned int* pSeed))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsRandGauss_64f function instead of this one and the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandUniformInitAlloc_8u, (IppsRandUniState_8u** pRandUniState,
                                   Ipp8u low, Ipp8u high, unsigned int seed))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandUniformInitAlloc_16s, (IppsRandUniState_16s** pRandUniState,
                                   Ipp16s low, Ipp16s high, unsigned int seed))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsRandUniformFree_8u,  (IppsRandUniState_8u* pRandUniState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsRandUniformFree_16s, (IppsRandUniState_16s* pRandUniState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandGaussInitAlloc_8u,   (IppsRandGaussState_8u** pRandGaussState,
                                   Ipp8u mean, Ipp8u stdDev, unsigned int seed))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsRandGaussInitAlloc_16s, (IppsRandGaussState_16s** pRandGaussState,
                                   Ipp16s mean, Ipp16s stdDev, unsigned int seed))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsRandGaussFree_8u,  (IppsRandGaussState_8u*  pRandGaussState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsRandGaussFree_16s, (IppsRandGaussState_16s* pRandGaussState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use GetSize and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsRandGaussFree_32f, (IppsRandGaussState_32f* pRandGaussState))

/* ////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRandGaussGetSize_8u, ippsRandGaussGetSize_16s
//              ippsRandGaussGetSize_32f
//
//  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_8u/16s/32f.
*/
IPPAPI(IppStatus, ippsRandGaussGetSize_8u,  (int * pRandGaussStateSize))
IPPAPI(IppStatus, ippsRandGaussGetSize_16s, (int * pRandGaussStateSize))
IPPAPI(IppStatus, ippsRandGaussGetSize_32f, (int * pRandGaussStateSize))

/* //////////////////////////////////////////////////////////////////////////////////
// Name:                ippsRandGaussInit_8u, ippsRandGaussInit_16s
//                      ippsRandGaussInit_32f
// 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_8u,  (IppsRandGaussState_8u* pRandGaussState,
                                   Ipp8u mean, Ipp8u stdDev, unsigned int seed))
IPPAPI(IppStatus, ippsRandGaussInit_16s, (IppsRandGaussState_16s* pRandGaussState,
                                   Ipp16s mean, Ipp16s stdDev, unsigned int seed))
IPPAPI(IppStatus, ippsRandGaussInit_32f, (IppsRandGaussState_32f* pRandGaussState,
                                   Ipp32f mean, Ipp32f stdDev, unsigned int seed))


/* ////////////////////////////////////////////////////////////////////////////
//  Name:       ippsRandUniformGetSize_8u, ippsRandUniformGetSize_16s
//              ippsRandUniformGetSize_32f
//
//  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_8u/16s/32f.
*/
IPPAPI(IppStatus, ippsRandUniformGetSize_8u,  (int * pRandUniformStateSize))
IPPAPI(IppStatus, ippsRandUniformGetSize_16s, (int * pRandUniformStateSize))
IPPAPI(IppStatus, ippsRandUniformGetSize_32f, (int * pRandUniformStateSize))


/* //////////////////////////////////////////////////////////////////////////////////
// Name:                ippsRandUniformInit_8u, ippsRandUniformInit_16s
//                      ippsRandUniformInit_32f
// 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_8u,  (IppsRandUniState_8u* pRandUniState,
                                   Ipp8u low, Ipp8u high, unsigned int seed))
IPPAPI(IppStatus, ippsRandUniformInit_16s, (IppsRandUniState_16s* pRandUniState,
                                   Ipp16s low, Ipp16s high, unsigned int seed))
IPPAPI(IppStatus, ippsRandUniformInit_32f, (IppsRandUniState_32f* pRandUniState,
                                   Ipp32f low, Ipp32f 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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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);
*/


IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTone_Direct_32f, (Ipp32f* pDst, int len, float magn,
                                float rFreq, float* pPhase, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTone_Direct_32fc, (Ipp32fc* pDst, int len, float magn,
                                float rFreq, float* pPhase, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTone_Direct_64f, (Ipp64f* pDst, int len, double magn,
                               double rFreq, double* pPhase, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTone_Direct_64fc, (Ipp64fc* pDst, int len, double magn,
                               double rFreq, double* pPhase, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTone_Direct_16s, (Ipp16s* pDst, int len, Ipp16s magn,
                                float rFreq, float* pPhase, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/


IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTriangle_Direct_64f, (Ipp64f* pDst, int len, double magn,
                                double rFreq, double asym, double* pPhase))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTriangle_Direct_64fc, (Ipp64fc* pDst, int len, double magn,
                                double rFreq, double asym, double* pPhase))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTriangle_Direct_32f, (Ipp32f* pDst, int len, float magn,
                                float rFreq, float asym, float* pPhase))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTriangle_Direct_32fc, (Ipp32fc* pDst, int len, float magn,
                                float rFreq, float asym, float* pPhase))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsTriangle_Direct_16s, (Ipp16s* pDst, int len, Ipp16s magn,
                                float rFreq, float asym, float* pPhase))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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.
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_8u,  (Ipp8u*  pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_8s,  (Ipp8s*  pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_16u, (Ipp16u* pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_16s, (Ipp16s* pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_32u, (Ipp32u* pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_32s, (Ipp32s* pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsVectorRamp_32f, (Ipp32f* pDst, int len, float offset, float slope))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Slope function instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsPolarToCart_32sc,(const Ipp32s* pSrcMagn,
                  const Ipp32s* pSrcPhase, int phaseFixedPoint, Ipp32sc* pDst, int len))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsPreemphasize_32f,(Ipp32f* pSrcDst, int len, Ipp32f val))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus,ippsUpdatePower_16s32s_I,(const Ipp16s* pSrc,int len,
       Ipp32s* pSrcDst, int srcShiftRight,Ipp16s alpha, IppHintAlgorithm hint))

/* /////////////////////////////////////////////////////////////////////////////
//  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 ) )
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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].
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsSplitScaled_16s32f_D2L,
        ( const Ipp16s* pSrc, Ipp32f** pDst, int nChannels, int chanLen ) )
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAddC_64u_Sfs, (const Ipp64u* pSrc, Ipp64u val, Ipp64u* pDst, Ipp32u len,
                                     int scaleFactor, IppRoundMode rndMode))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAddC_64s_Sfs, (const Ipp64s* pSrc, Ipp64s val, Ipp64s* pDst, Ipp32u len,
                                     int scaleFactor, IppRoundMode rndMode))

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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAdd_16u,    (const Ipp16u*  pSrc1, const Ipp16u*  pSrc2,
       Ipp16u*  pDst, int len))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAdd_32u,    (const Ipp32u*  pSrc1, const Ipp32u*  pSrc2,
       Ipp32u*  pDst, int len))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAdd_16s32f, (const Ipp16s*  pSrc1, const Ipp16s*  pSrc2,
       Ipp32f*  pDst, int len))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsSub_16s32f, (const Ipp16s*  pSrc1, const Ipp16s*  pSrc2,
       Ipp32f*  pDst, int len))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAdd_64s_Sfs,    (const Ipp64s*  pSrc1, const Ipp64s*  pSrc2,
       Ipp64s*  pDst, int 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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsMul_16u16s_Sfs, (const Ipp16u* pSrc1, const Ipp16s* pSrc2,
       Ipp16s* pDst, int len, int scaleFactor))


IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsMul_32s32sc_ISfs, (const Ipp32s* pSrc, Ipp32sc* pSrcDst,
       int len, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsMul_32s32sc_Sfs,  (const Ipp32s* pSrc1, const Ipp32sc* pSrc2,
       Ipp32sc* pDst, int len, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsSqrt_16s_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus,ippsSqrt_16s_ISfs,(Ipp16s* pSrcDst,int len,int scaleFactor))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsSqrt_16sc_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus,ippsSqrt_64s_ISfs,(Ipp64s* pSrcDst,int len,int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus,ippsSqrt_64s_Sfs,(const Ipp64s* pSrc,Ipp64s* pDst,int len,
                                   int scaleFactor))

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsSqrt_8u_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsSqrt_16u_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use PowerSpectr functionality instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsMagSquared_32sc32s_Sfs, (const Ipp32sc* pSrc, Ipp32s* pDst, int len, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use PowerSpectr functionality instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsExp_64s_Sfs,(const Ipp64s* pSrc, Ipp64s* pDst, int len,
   int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ipps10Log10_32s_ISfs,( Ipp32s* pSrcDst, int Len, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/


IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsSumLn_32f,(const Ipp32f* pSrc, int len, Ipp32f* pSum))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsSumLn_64f,(const Ipp64f* pSrc, int len, Ipp64f* pSum))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsSumLn_32f64f,(const Ipp32f* pSrc, int len, Ipp64f* pSum))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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_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, ippsMinEvery_8u,  ( const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMaxEvery_8u,  ( const Ipp8u* pSrc1, const Ipp8u* pSrc2, Ipp8u* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMinEvery_16u, ( const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMaxEvery_16u, ( const Ipp16u* pSrc1, const Ipp16u* pSrc2, Ipp16u* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMinEvery_32f, ( const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMaxEvery_32f, ( const Ipp32f* pSrc1, const Ipp32f* pSrc2, Ipp32f* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMinEvery_64f, ( const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, Ipp32u len ))
IPPAPI(IppStatus, ippsMaxEvery_64f, ( const Ipp64f* pSrc1, const Ipp64f* pSrc2, Ipp64f* pDst, Ipp32u 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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDotProd_16s_Sfs, (const Ipp16s* pSrc1,
       const Ipp16s* pSrc2, int len, Ipp16s* pDp, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDotProd_16sc_Sfs,(const Ipp16sc* pSrc1,
       const Ipp16sc* pSrc2, int len, Ipp16sc* pDp, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDotProd_16sc32fc, (const Ipp16sc* pSrc1,
       const Ipp16sc* pSrc2, int len, Ipp32fc* pDp))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI ( IppStatus, ippsDotProd_16sc32sc_Sfs,
        ( const Ipp16sc* pSrc1, const Ipp16sc* pSrc2,
          int len, Ipp32sc* pDp, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI ( IppStatus, ippsDotProd_32sc_Sfs,
        ( const Ipp32sc* pSrc1, const Ipp32sc* pSrc2,
          int len, Ipp32sc* pDp, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:    Computes the size of the FFT context structure and the size
                of the required work buffer (in bytes)
//  Arguments:
//     order      Base-2 logarithm of the number of samples in FFT
//     flag       Flag to choose the results normalization factors
//     hint       Option to select the algorithmic implementation of the transform
//                function
//     pSizeSpec  Pointer to the size value of FFT specification structure
//     pSizeInit  Pointer to the size value of the buffer for FFT initialization function
//     pSizeBuf   Pointer to the size value of the FFT external work buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsFftOrderErr      FFT order value is illegal
//     ippStsFFTFlagErr       Incorrect 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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_C_16sc,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_C_16s,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_R_16s,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_C_32sc,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_C_32s,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetSize_R_32s,
                   ( int order, int flag, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:    Initializes the FFT context structure
//  Arguments:
//     order        Base-2 logarithm of the number of samples in FFT
//     flag         Flag to choose the results normalization factors
//     hint         Option to select the algorithmic implementation of the transform
//                  function
//     ppFFTSpec    Double pointer to the FFT specification structure to be created
//     pSpec        Pointer to the FFT specification structure
//     pSpecBuffer  Pointer to the temporary work buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsFftOrderErr      FFT order value is illegal
//     ippStsFFTFlagErr       Incorrect 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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_C_16sc,
                   ( IppsFFTSpec_C_16sc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_C_16s,
                   ( IppsFFTSpec_C_16s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_R_16s,
                   ( IppsFFTSpec_R_16s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_C_32sc,
                   ( IppsFFTSpec_C_32sc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_C_32s,
                   ( IppsFFTSpec_C_32s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInit_R_32s,
                   ( IppsFFTSpec_R_32s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:    Allocates and initializes the FFT specification structure
//  Arguments:
//     order       Base-2 logarithm of the number of samples in FFT
//     flag        Flag to choose the results normalization factors
//     hint        Option to select the algorithmic implementation of the transform
//                 function
//     ppFFTSpec   Double pointer to the FFT context structure
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       ppFFTSpec == NULL
//     ippStsFftOrderErr      FFT order value is illegal
//     ippStsFFTFlagErr       Incorrect normalization flag value
//     ippStsMemAllocErr      Memory allocation fails
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32fc,
                   ( IppsFFTSpec_C_32fc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32f,
                   ( IppsFFTSpec_C_32f** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_R_32f,
                   ( IppsFFTSpec_R_32f** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_64fc,
                   ( IppsFFTSpec_C_64fc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_64f,
                   ( IppsFFTSpec_C_64f** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_R_64f,
                   ( IppsFFTSpec_R_64f** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_16sc,
                   ( IppsFFTSpec_C_16sc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_16s,
                   ( IppsFFTSpec_C_16s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_R_16s,
                   ( IppsFFTSpec_R_16s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32sc,
                   ( IppsFFTSpec_C_32sc** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_C_32s,
                   ( IppsFFTSpec_C_32s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_R_32s,
                   ( IppsFFTSpec_R_32s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInitAlloc_R_16s32s,
                   ( IppsFFTSpec_R_16s32s** ppFFTSpec,
                     int order, int flag, IppHintAlgorithm hint ))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFFTFree_C, ippsFFTFree_R
//  Purpose:    Closes the DFT specification structure
//  Arguments:
//     pFFTSpec  Pointer to the FFT context structure
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       pFFTSpec == NULL
//     ippStsContextMatchErr  Invalid context structure
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_32fc,   ( IppsFFTSpec_C_32fc* pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_32f,    ( IppsFFTSpec_C_32f*  pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_R_32f,    ( IppsFFTSpec_R_32f*  pFFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_64fc,   ( IppsFFTSpec_C_64fc* pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_64f,    ( IppsFFTSpec_C_64f*  pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_R_64f,    ( IppsFFTSpec_R_64f*  pFFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_16sc,   ( IppsFFTSpec_C_16sc* pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_16s,    ( IppsFFTSpec_C_16s*  pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_R_16s,    ( IppsFFTSpec_R_16s*  pFFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_32sc,   ( IppsFFTSpec_C_32sc* pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_C_32s,    ( IppsFFTSpec_C_32s*  pFFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_R_32s,    ( IppsFFTSpec_R_32s*  pFFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFree_R_16s32s, ( IppsFFTSpec_R_16s32s* pFFTSpec ))

/* /////////////////////////////////////////////////////////////////////////////
//                  FFT Buffer Size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFFTGetBufSize_C, ippsFFTGetBufSize_R
//  Purpose:    Computes the size of the FFT work buffer (in bytes)
//  Arguments:
//     pFFTSpec      Pointer to the FFT context structure
//     pBufferSize   Pointer to the size of the external buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsContextMatchErr  Invalid context structure
*/

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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_C_16sc,
                   ( const IppsFFTSpec_C_16sc* pFFTSpec, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_C_16s,
                   ( const IppsFFTSpec_C_16s*  pFFTSpec, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_R_16s,
                   ( const IppsFFTSpec_R_16s*  pFFTSpec, int* pBufferSize ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32sc,
                   ( const IppsFFTSpec_C_32sc* pFFTSpec, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_C_32s,
                   ( const IppsFFTSpec_C_32s*  pFFTSpec, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_R_32s,
                   ( const IppsFFTSpec_R_32s*  pFFTSpec, int* pBufferSize ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTGetBufSize_R_16s32s,
                   ( const IppsFFTSpec_R_16s32s* pFFTSpec, int* pBufferSize ))

/* /////////////////////////////////////////////////////////////////////////////
//                  FFT Complex Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFFTFwd_CToC, ippsFFTInv_CToC
//  Purpose:    Computes forward and inverse FFT of a complex signal
//  Arguments:
//     pFFTSpec     Pointer to the FFT context
//     pSrc         Pointer to the source complex signal
//     pDst         Pointer to the destination complex signal
//     pSrcRe       Pointer to the real      part of source signal
//     pSrcIm       Pointer to the imaginary part of source signal
//     pDstRe       Pointer to the real      part of destination signal
//     pDstIm       Pointer to the imaginary part of destination signal
//     pSrcDst      Pointer to the complex signal
//     pSrcDstRe    Pointer to the real      part of signal
//     pSrcDstIm    Pointer to the imaginary part of signal
//     pBuffer      Pointer to the work buffer
//     scaleFactor  Scale factor for output result
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers with the exception of
                              pBuffer is NULL
//     ippStsContextMatchErr  Invalid context structure
//     ippStsMemAllocErr      Memory allocation fails
*/

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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_16sc_Sfs,
                   ( const Ipp16sc* pSrc, Ipp16sc* pDst,
                     const IppsFFTSpec_C_16sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CToC_16sc_Sfs,
                   ( const Ipp16sc* pSrc, Ipp16sc* pDst,
                     const IppsFFTSpec_C_16sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_16sc_ISfs,
                   ( Ipp16sc* pSrcDst,
                     const IppsFFTSpec_C_16sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CToC_16sc_ISfs,
                   ( Ipp16sc* pSrcDst,
                     const IppsFFTSpec_C_16sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_16s_ISfs,
                   ( Ipp16s* pSrcDstRe, Ipp16s* pSrcDstIm,
                     const IppsFFTSpec_C_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CToC_16s_ISfs,
                   ( Ipp16s* pSrcDstRe, Ipp16s* pSrcDstIm,
                     const IppsFFTSpec_C_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_32sc_Sfs,
                   ( const Ipp32sc* pSrc, Ipp32sc* pDst,
                     const IppsFFTSpec_C_32sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CToC_32sc_Sfs,
                   ( const Ipp32sc* pSrc, Ipp32sc* pDst,
                     const IppsFFTSpec_C_32sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_32sc_ISfs,
                   ( Ipp32sc* pSrcDst,
                     const IppsFFTSpec_C_32sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CToC_32sc_ISfs,
                   ( Ipp32sc* pSrcDst,
                     const IppsFFTSpec_C_32sc* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_CToC_32s_ISfs,
                   ( Ipp32s* pSrcDstRe, Ipp32s* pSrcDstIm,
                     const IppsFFTSpec_C_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:    Computes forward and inverse FFT of a real signal
//              using Perm, Pack or Ccs packed format
//  Arguments:
//     pFFTSpec       Pointer to the FFT context
//     pSrc           Pointer to the source signal
//     pDst           Pointer to thedestination signal
//     pSrcDst        Pointer to the source/destination signal (in-place)
//     pBuffer        Pointer to the work buffer
//     scaleFactor    Scale factor for output result
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers with the exception of
                              pBuffer is NULL
//     ippStsContextMatchErr  Invalid context structure
//     ippStsMemAllocErr      Memory allocation fails
*/

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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPack_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PermToR_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PackToR_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CCSToR_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPack_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PermToR_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PackToR_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CCSToR_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsFFTSpec_R_16s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PermToR_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PackToR_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32s_Sfs,
                   ( const Ipp32s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPerm_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToPack_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PermToR_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_PackToR_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTInv_CCSToR_32s_ISfs,
                   ( Ipp32s* pSrcDst,
                     const IppsFFTSpec_R_32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsFFTFwd_RToCCS_16s32s_Sfs,
                   ( const Ipp16s* pSrc, Ipp32s* pDst,
                     const IppsFFTSpec_R_16s32s* pFFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:       ippsDFTGetSize_C, ippsDFTGetSize_R
//  Purpose:    Computes the size of the DFT context structure and the size
                of the required work buffer (in bytes)
//  Arguments:
//     length     Length of the DFT transform
//     flag       Flag to choose the results normalization factors
//     hint       Option to select the algorithmic implementation of the transform
//                function
//     pSizeSpec  Pointer to the size value of DFT specification structure
//     pSizeInit  Pointer to the size value of the buffer for DFT initialization function
//     pSizeBuf   Pointer to the size value of the DFT external work buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsOrderErr         Invalid length value
//     ippStsFFTFlagErr       Incorrect normalization flag value
//     ippStsSizeErr          Indicates an error when length is less than or equal to 0
*/

IPPAPI (IppStatus, ippsDFTGetSize_C_32fc,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
IPPAPI (IppStatus, ippsDFTGetSize_C_32f,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
IPPAPI (IppStatus, ippsDFTGetSize_R_32f,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))

IPPAPI (IppStatus, ippsDFTGetSize_C_64fc,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
IPPAPI (IppStatus, ippsDFTGetSize_C_64f,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
IPPAPI (IppStatus, ippsDFTGetSize_R_64f,
                   ( int length, int flag, IppHintAlgorithm hint,
                     int* pSizeSpec, int* pSizeInit, int* pSizeBuf ))
/* /////////////////////////////////////////////////////////////////////////////
//                  DFT Init Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsDFTInit_C, ippsDFTInit_R
//  Purpose:    initialize of DFT context
//  Arguments:
//     length     Length of the DFT transform
//     flag       Flag to choose the results normalization factors
//     hint       Option to select the algorithmic implementation of the transform
//                function
//     pDFTSpec   Double pointer to the DFT context structure
//     pMemInit   Pointer to initialization buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsOrderErr         Invalid length value
//     ippStsFFTFlagErr       Incorrect normalization flag value
//     ippStsSizeErr          Indicates an error when length is less than or equal to 0
*/

IPPAPI (IppStatus, ippsDFTInit_C_32fc,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_C_32fc* pDFTSpec, Ipp8u* pMemInit ))
IPPAPI (IppStatus, ippsDFTInit_C_32f,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_C_32f* pDFTSpec, Ipp8u* pMemInit ))
IPPAPI (IppStatus, ippsDFTInit_R_32f,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_R_32f* pDFTSpec, Ipp8u* pMemInit ))

IPPAPI (IppStatus, ippsDFTInit_C_64fc,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_C_64fc* pDFTSpec, Ipp8u* pMemInit ))
IPPAPI (IppStatus, ippsDFTInit_C_64f,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_C_64f* pDFTSpec, Ipp8u* pMemInit ))
IPPAPI (IppStatus, ippsDFTInit_R_64f,
                   ( int length, int flag, IppHintAlgorithm hint,
                   IppsDFTSpec_R_64f* pDFTSpec, Ipp8u* pMemInit ))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsDFTInitAlloc_C, ippsDFTInitAlloc_R
//  Purpose:    Allocates and initializes the DFT specification structure
//  Arguments:
//     length     Length of the DFT transform
//     flag       Flag to choose the results normalization factors
//     hint       Option to select the algorithmic implementation of the transform
//                function
//     pDFTSpec   Double pointer to the DFT context structure
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       pDFTSpec == NULL
//     ippStsFftOrderErr      FFT order value is illegal
//     ippStsFFTFlagErr       Incorrect normalization flag value
//     ippStsMemAllocErr      Memory allocation fails
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_16sc,
                   ( IppsDFTSpec_C_16sc** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_16s,
                   ( IppsDFTSpec_C_16s** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_R_16s,
                   ( IppsDFTSpec_R_16s** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_32fc,
                   ( IppsDFTSpec_C_32fc** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_32f,
                   ( IppsDFTSpec_C_32f** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_R_32f,
                   ( IppsDFTSpec_R_32f** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_64fc,
                   ( IppsDFTSpec_C_64fc** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_C_64f,
                   ( IppsDFTSpec_C_64f** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInitAlloc_R_64f,
                   ( IppsDFTSpec_R_64f** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdInitAlloc_C_32fc,
                   ( IppsDFTOutOrdSpec_C_32fc** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdInitAlloc_C_64fc,
                   ( IppsDFTOutOrdSpec_C_64fc** pDFTSpec,
                     int length, int flag, IppHintAlgorithm hint ))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsDFTFree_C, ippsDFTFree_R
//  Purpose:    Closes the DFT specification structure
//  Arguments:
//     pDFTSpec  Pointer to the DFT context structure
//  Returns:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       pDFTSpec == NULL
//     ippStsContextMatchErr  Invalid context structure
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_16sc, ( IppsDFTSpec_C_16sc* pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_16s,  ( IppsDFTSpec_C_16s*  pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_R_16s,  ( IppsDFTSpec_R_16s*  pDFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_32fc, ( IppsDFTSpec_C_32fc* pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_32f,  ( IppsDFTSpec_C_32f*  pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_R_32f,  ( IppsDFTSpec_R_32f*  pDFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_64fc, ( IppsDFTSpec_C_64fc* pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_C_64f,  ( IppsDFTSpec_C_64f*  pDFTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFree_R_64f,  ( IppsDFTSpec_R_64f*  pDFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdFree_C_32fc, ( IppsDFTOutOrdSpec_C_32fc* pDFTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdFree_C_64fc, ( IppsDFTOutOrdSpec_C_64fc* pDFTSpec ))


/* /////////////////////////////////////////////////////////////////////////////
//                  DFT Buffer Size
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsDFTGetBufSize_C, ippsDFTGetBufSize_R
//  Purpose:    Computes the size of the DFT work buffer (in bytes)
//  Arguments:
//     pFFTSpec      Pointer to the DFT context structure
//     pBufferSize   Pointer to the size of the external buffer
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers is NULL
//     ippStsContextMatchErr  Invalid context structure
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTGetBufSize_C_16sc,
                   ( const IppsDFTSpec_C_16sc* pDFTSpec, int* pSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTGetBufSize_C_16s,
                   ( const IppsDFTSpec_C_16s*  pDFTSpec, int* pSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdGetBufSize_C_32fc,
                   ( const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, int* size ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdGetBufSize_C_64fc,
                   ( const IppsDFTOutOrdSpec_C_64fc* pDFTSpec, int* size ))


/* /////////////////////////////////////////////////////////////////////////////
//                  DFT Complex Transforms
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsDFTFwd_CToC, ippsDFTInv_CToC
//  Purpose:    Computes forward and inverse DFT of a complex signal
//  Arguments:
//     pDFTSpec     Pointer to the DFT context
//     pSrc         Pointer to the source complex signal
//     pDst         Pointer to the destination complex signal
//     pSrcRe       Pointer to the real      part of source signal
//     pSrcIm       Pointer to the imaginary part of source signal
//     pDstRe       Pointer to the real      part of destination signal
//     pDstIm       Pointer to the imaginary part of destination signal
//     pBuffer      Pointer to the work buffer
//     scaleFactor  Scale factor for output result
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers with the exception of
                              pBuffer is NULL
//     ippStsContextMatchErr  Invalid context structure
//     ippStsMemAllocErr      Memory allocation fails
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFwd_CToC_16sc_Sfs,
                   ( const Ipp16sc* pSrc, Ipp16sc* pDst,
                     const IppsDFTSpec_C_16sc* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInv_CToC_16sc_Sfs,
                   ( const Ipp16sc* pSrc, Ipp16sc* pDst,
                     const IppsDFTSpec_C_16sc* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdFwd_CToC_32fc,
                   ( const Ipp32fc* pSrc, Ipp32fc* pDst,
                     const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdInv_CToC_32fc,
                   ( const Ipp32fc* pSrc, Ipp32fc* pDst,
                     const IppsDFTOutOrdSpec_C_32fc* pDFTSpec, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTOutOrdFwd_CToC_64fc,
                   ( const Ipp64fc* pSrc, Ipp64fc* pDst,
                     const IppsDFTOutOrdSpec_C_64fc* pDFTSpec, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 a real signal
//              using Perm, Pack or Ccs packed format
//  Arguments:
//     pFFTSpec       Pointer to the DFT context
//     pSrc           Pointer to the source signal
//     pDst           Pointer to the destination signal
//     pSrcDst        Pointer to the source/destination signal (in-place)
//     pBuffer        Pointer to the work buffer
//     scaleFactor    Scale factor for output result
//  Return:
//     ippStsNoErr            No errors
//     ippStsNullPtrErr       One of the specified pointers with the exception of
                              pBuffer is NULL
//     ippStsContextMatchErr  Invalid context structure
//     ippStsMemAllocErr      Memory allocation fails
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFwd_RToPerm_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDFTSpec_R_16s* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFwd_RToPack_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDFTSpec_R_16s* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTFwd_RToCCS_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDFTSpec_R_16s* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInv_PermToR_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDFTSpec_R_16s* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDFTInv_PackToR_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDFTSpec_R_16s* pDFTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsGoertzTwo_32fc, (const Ipp32fc* pSrc, int len,
       Ipp32fc val[2], const Ipp32f rFreq[2] ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsGoertzTwo_64fc, (const Ipp64fc* pSrc, int len,
       Ipp64fc val[2], const Ipp64f rFreq[2] ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsGoertzTwo_16sc_Sfs, (const Ipp16sc* pSrc, int len,
       Ipp16sc val[2], const Ipp32f rFreq[2], int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsGoertzTwo_32f, (const Ipp32f* pSrc, int len,
       Ipp32fc val[2], const Ipp32f rFreq[2] ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdGetSize_16s,
                   ( int len, IppHintAlgorithm hint,
                     int* pSpecSize, int* pSpecBufferSize, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdInit_16s,
                   ( IppsDCTFwdSpec_16s** ppDCTSpec,
                     int len, IppHintAlgorithm hint,
                     Ipp8u* pSpec, Ipp8u* pSpecBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdInitAlloc_16s,
                   ( IppsDCTFwdSpec_16s** ppDCTSpec,
                     int len, IppHintAlgorithm hint ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdFree_16s, ( IppsDCTFwdSpec_16s*  pDCTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTInvFree_16s, ( IppsDCTInvSpec_16s*  pDCTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdFree_32f, ( IppsDCTFwdSpec_32f*  pDCTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTInvFree_32f, ( IppsDCTInvSpec_32f*  pDCTSpec ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdFree_64f, ( IppsDCTFwdSpec_64f*  pDCTSpec ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwdGetBufSize_16s,
                   ( const IppsDCTFwdSpec_16s* pDCTSpec, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwd_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDCTFwdSpec_16s* pDCTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTInv_16s_Sfs,
                   ( const Ipp16s* pSrc, Ipp16s* pDst,
                     const IppsDCTInvSpec_16s* pDCTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))

IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsDCTFwd_16s_ISfs,
                   ( Ipp16s* pSrcDst,
                     const IppsDCTFwdSpec_16s* pDCTSpec,
                     int scaleFactor, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. Integer APIs for linear transforms are obsolete and will be removed in one of the future IPP releases. All linear-transform functions are FP internally - use FP variant of this function. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTHaarFwd_32s,
                   ( const Ipp32s* pSrc, int len,
                        Ipp32s* pDstLow, Ipp32s* pDstHigh ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTHaarFwd_64s_Sfs,
                   ( const Ipp64s* pSrc, int len,
                        Ipp64s* pDstLow, Ipp64s* pDstHigh, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTHaarInv_32s,
                   ( const Ipp32s* pSrcLow, const Ipp32s* pSrcHigh,
                                Ipp32s* pDst, int len ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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.
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTFwdFree_32f, (IppsWTFwdState_32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTFwdFree_8s32f, (IppsWTFwdState_8s32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTFwdFree_8u32f, (IppsWTFwdState_8u32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTFwdFree_16s32f, (IppsWTFwdState_16s32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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.
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTInvFree_32f, (IppsWTInvState_32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTInvFree_32f8s, (IppsWTInvState_32f8s* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTInvFree_32f8u, (IppsWTInvState_32f8u* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTInvFree_32f16s, (IppsWTInvState_32f16s* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI (IppStatus, ippsWTInvFree_32f16u, (IppsWTInvState_32f16u* pState))



/* /////////////////////////////////////////////////////////////////////////////
//                  Filtering
///////////////////////////////////////////////////////////////////////////// */


/* /////////////////////////////////////////////////////////////////////////////
//                  Convolution functions
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Names:  ippsConvolveGetBufferSize
//
//  Purpose:     Get the size (in bytes) of the buffer for ippsConvolve's internal calculations.
//
//  Parameters:
//    src1Len     - Length of the first source vector.
//    src2Len     - Length of the second source vector.
//    dataType    - Data type for convolution {Ipp32f|Ipp64f}.
//    algType     - Selector for the algorithm type. Contains IppAlgType values.
//    pBufferSize - Pointer to the calculated buffer size (in bytes).
//  Return:
//   ippStsNoErr       - OK
//   ippStsNullPtrErr  - pBufferSize is NULL.
//   ippStsSizeErr     - Vector's length is not positive.
//   ippStsDataTypeErr - Unsupported data type.
//   ippStsAlgTypeErr - Unsupported algorithm type.
*/

IPPAPI( IppStatus, ippsConvolveGetBufferSize, ( int src1Len, int src2Len, IppDataType dataType, IppEnum algType, int* pBufferSize ))


/* /////////////////////////////////////////////////////////////////////////////
// Name:       ippsConvolve_32f, ippsConvolve_64f
// Purpose:    Perform a linear convolution of 1D signals.
// Parameters:
//    pSrc1   - Pointer to the first source vector.
//    src1Len - Length of the first source vector.
//    pSrc2   - Pointer to the second source vector.
//    src2Len - Length of the second source vector.
//    pDst    - Pointer to the destination vector.
//    algType - Selector for the algorithm type. Contains IppAlgType values.
//    pBuffer - Pointer to the buffer for internal calculations.
// Returns:    IppStatus
//    ippStsNoErr       - OK.
//    ippStsNullPtrErr  - One of the pointers is NULL.
//    ippStsSizeErr     - Vector's length is not positive.
//    ippStsAlgTypeErr  - Unsupported algorithm type.
//  Notes:
//          Length of the destination data vector is src1Len+src2Len-1.
//          The input signals are exchangeable because of the commutative
//          property of convolution.
//          Some other values may be returned the by FFT transform functions.
*/

IPPAPI( IppStatus, ippsConvolve_32f,( const Ipp32f* pSrc1, int src1Len, const Ipp32f* pSrc2, int src2Len, Ipp32f* pDst, IppEnum algType, Ipp8u* pBuffer ))
IPPAPI( IppStatus, ippsConvolve_64f,( const Ipp64f* pSrc1, int src1Len, const Ipp64f* pSrc2, int src2Len, Ipp64f* pDst, IppEnum algType, Ipp8u* pBuffer ))


/* /////////////////////////////////////////////////////////////////////////////
//  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
*/

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsConvolve_32f. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsConv_32f, ( const Ipp32f* pSrc1, int lenSrc1, const Ipp32f* pSrc2, int lenSrc2, Ipp32f* pDst))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsConvolve_64f. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsConv_64f, ( const Ipp64f* pSrc1, int lenSrc1, const Ipp64f* pSrc2, int lenSrc2, Ipp64f* pDst))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsConvert_16s32f and ippsConvolve_32f instead of this one. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsConv_16s_Sfs, ( const Ipp16s* pSrc1, int lenSrc1, const Ipp16s* pSrc2, int lenSrc2, Ipp16s* pDst, int scaleFactor))


/* /////////////////////////////////////////////////////////////////////////////
//  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.
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsConvCyclic8x8_32f,( const Ipp32f* x,
       const Ipp32f* h, Ipp32f* y ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsConvCyclic8x8_16s_Sfs,( const Ipp16s* x,
       const Ipp16s* h, Ipp16s* y, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_32f, (IppsIIRState_32f** ppState,
       const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_32fc, (IppsIIRState_32fc** ppState,
       const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32f_16s, (IppsIIRState32f_16s** ppState,
       const Ipp32f* pTaps, int order, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32fc_16sc, (IppsIIRState32fc_16sc** ppState,
       const Ipp32fc* pTaps, int order, const Ipp32fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_64f, (IppsIIRState_64f** ppState,
       const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_64fc, (IppsIIRState_64fc** ppState,
       const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_32f, (IppsIIRState64f_32f** ppState,
       const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_32fc, (IppsIIRState64fc_32fc** ppState,
       const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_32s, (IppsIIRState64f_32s** ppState,
       const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_32sc, (IppsIIRState64fc_32sc** ppState,
       const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_16s, (IppsIIRState64f_16s** ppState,
       const Ipp64f* pTaps, int order, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_16sc, (IppsIIRState64fc_16sc** ppState,
       const Ipp64fc* pTaps, int order, const Ipp64fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree_32f, (IppsIIRState_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree_32fc, (IppsIIRState_32fc* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree32f_16s, (IppsIIRState32f_16s* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree32fc_16sc, (IppsIIRState32fc_16sc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree_64f, (IppsIIRState_64f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree_64fc, (IppsIIRState_64fc* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree64f_32f, (IppsIIRState64f_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree64fc_32fc, (IppsIIRState64fc_32fc* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree64f_32s, (IppsIIRState64f_32s* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree64fc_32sc, (IppsIIRState64fc_32sc* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree64f_16s, (IppsIIRState64f_16s* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_32f, (IppsIIRState_32f** ppState,
       const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_32fc, (IppsIIRState_32fc** ppState,
       const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32f_BiQuad_16s, (IppsIIRState32f_16s** ppState,
       const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32fc_BiQuad_16sc, (IppsIIRState32fc_16sc** ppState,
       const Ipp32fc* pTaps, int numBq, const Ipp32fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_64f, (IppsIIRState_64f** ppState,
       const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc_BiQuad_64fc, (IppsIIRState_64fc** ppState,
       const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_32f, (IppsIIRState64f_32f** ppState,
       const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_BiQuad_32fc, (IppsIIRState64fc_32fc** ppState,
       const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_32s, (IppsIIRState64f_32s** ppState,
       const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64fc_BiQuad_32sc, (IppsIIRState64fc_32sc** ppState,
       const Ipp64fc* pTaps, int numBq, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc64f_BiQuad_16s, (IppsIIRState64f_16s** ppState,
       const Ipp64f* pTaps, int numBq, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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];
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInitAlloc_BiQuad_DF1_32f,( IppsIIRState_32f** pState,
                   const Ipp32f* pTaps, int numBq, const Ipp32f* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRGetDlyLine64f_DF1_32s, (const IppsIIRState64f_32s* pState, Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne_32f, (Ipp32f src, Ipp32f* pDstVal, IppsIIRState_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsIIRState_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne32f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState32f_16s* pState, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne32fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, IppsIIRState32fc_16sc* pState, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne_64f, (Ipp64f src, Ipp64f* pDstVal, IppsIIRState_64f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne_64fc, (Ipp64fc src, Ipp64fc* pDstVal, IppsIIRState_64fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne64f_32f, (Ipp32f src, Ipp32f* pDstVal, IppsIIRState64f_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne64fc_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsIIRState64fc_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne64f_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal, IppsIIRState64f_32s* pState, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne64fc_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal, IppsIIRState64fc_32sc* pState, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne64f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState64f_16s* pState, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsIIR64f_32s_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsIIR64fc_32sc_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsIIR64f_16s_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsIIR64fc_16sc_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_32f_P,( const Ipp32f **ppSrc, Ipp32f **ppDst, int len,
       int nChannels, IppsIIRState_32f **ppState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_32f_IP,( Ipp32f **ppSrcDst, int len,
       int nChannels, IppsIIRState_32f **ppState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIR64f_32s_PSfs, (const Ipp32s **ppSrc, Ipp32s **ppDst, int len,
       int nChannels, IppsIIRState64f_32s **ppState, int *pScaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32s_16s, (IppsIIRState32s_16s** ppState,
       const Ipp32s* pTaps, int order, int tapsFactor, const Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32s_16s32f, (IppsIIRState32s_16s** ppState,
       const Ipp32f* pTaps, int order, const Ipp32s* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_16sc, (IppsIIRState32sc_16sc** ppState,
       const Ipp32sc* pTaps, int order, int tapsFactor, const Ipp32sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_16sc32fc, (IppsIIRState32sc_16sc** ppState,
       const Ipp32fc* pTaps, int order, const Ipp32sc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32s_BiQuad_16s, (IppsIIRState32s_16s** ppState,
       const Ipp32s* pTaps, int numBq, int tapsFactor, const Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32s_BiQuad_16s32f, (IppsIIRState32s_16s** ppState,
       const Ipp32f* pTaps, int numBq, const Ipp32s* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_BiQuad_16sc, (IppsIIRState32sc_16sc** ppState,
       const Ipp32sc* pTaps, int numBq, int tapsFactor, const Ipp32sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRInitAlloc32sc_BiQuad_16sc32fc, (IppsIIRState32sc_16sc** ppState,
       const Ipp32fc* pTaps, int numBq, const Ipp32sc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRFree32s_16s, (IppsIIRState32s_16s* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRGetDlyLine32s_16s, (const IppsIIRState32s_16s* pState, Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRSetDlyLine32s_16s, (IppsIIRState32s_16s* pState, const Ipp32s* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIRGetDlyLine32sc_16sc, (const IppsIIRState32sc_16sc* pState, Ipp32sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIROne32s_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, IppsIIRState32s_16s* pState, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIR32s_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int len,
       IppsIIRState32s_16s* pState, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIR32sc_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int len,
       IppsIIRState32sc_16sc* pState, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsIIR32s_16s_ISfs, (Ipp16s* pSrcDst, int len, IppsIIRState32s_16s* pState,
       int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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.
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_Direct_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
                 int len, const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_Direct_16s_I,( Ipp16s* pSrcDst, int len,
                          const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIROne_Direct_16s,( Ipp16s src, Ipp16s* pDstVal,
                          const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIROne_Direct_16s_I,( Ipp16s* pSrcDst,
                          const Ipp16s* pTaps, int order, Ipp32s* pDlyLine ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_BiQuadDirect_16s,( const Ipp16s* pSrc, Ipp16s* pDst,
             int len, const Ipp16s* pTaps, int numBq, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIR_BiQuadDirect_16s_I,( Ipp16s* pSrcDst, int len,
                     const Ipp16s * pTaps, int numBq, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIROne_BiQuadDirect_16s,( Ipp16s src, Ipp16s* pDstVal,
                      const Ipp16s* pTaps, int numBq, Ipp32s* pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ******************************** */
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32s_16s,( int order, int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_16sc,( int order,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32s_BiQuad_16s,( int numBq,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_BiQuad_16sc,( int numBq,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32s_16s,( IppsIIRState32s_16s** ppState,
                                const Ipp32s* pTaps, int order, int tapsFactor,
                                         const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32sc_16sc,( IppsIIRState32sc_16sc** ppState,
                               const Ipp32sc* pTaps, int order, int tapsFactor,
                                        const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32s_BiQuad_16s,( IppsIIRState32s_16s** ppState,
                                const Ipp32s* pTaps, int numBq, int tapsFactor,
                                         const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32sc_BiQuad_16sc,(
                   IppsIIRState32sc_16sc** ppState, const Ipp32sc* pTaps,
             int numBq, int tapsFactor, const Ipp32sc* pDlyLine, Ipp8u* pBuf ))

/* ****************************** 32s_16s32f ******************************* */
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32s_16s32f,( int order,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_16sc32fc,( int order,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32s_BiQuad_16s32f,( int numBq,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRGetStateSize32sc_BiQuad_16sc32fc,( int numBq,
                                                            int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32s_16s32f,( IppsIIRState32s_16s** ppState,
         const Ipp32f* pTaps, int order, const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32sc_16sc32fc,( IppsIIRState32sc_16sc** ppState,
                                               const Ipp32fc* pTaps, int order,
                                        const Ipp32sc* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRInit32s_BiQuad_16s32f,( IppsIIRState32s_16s** ppState,
                                                const Ipp32f* pTaps, int numBq,
                                         const Ipp32s* pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps_32f,( const Ipp32f *pTaps,
                                                    IppsIIRState_32f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps_32fc,( const Ipp32fc *pTaps,
                                                   IppsIIRState_32fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32f_16s,( const Ipp32f *pTaps,
                                                 IppsIIRState32f_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32fc_16sc,( const Ipp32fc *pTaps,
                                               IppsIIRState32fc_16sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32s_16s,( const Ipp32s *pTaps,
                                 IppsIIRState32s_16s* pState, int tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32sc_16sc,( const Ipp32sc *pTaps,
                               IppsIIRState32sc_16sc* pState, int tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32s_16s32f,( const Ipp32f *pTaps,
                                                 IppsIIRState32s_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps32sc_16sc32fc,( const Ipp32fc *pTaps,
                                               IppsIIRState32sc_16sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps_64f,( const Ipp64f *pTaps,
                                                    IppsIIRState_64f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps_64fc,( const Ipp64fc *pTaps,
                                                   IppsIIRState_64fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps64f_32f,( const Ipp64f *pTaps,
                                                 IppsIIRState64f_32f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps64fc_32fc,( const Ipp64fc *pTaps,
                                               IppsIIRState64fc_32fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps64f_32s,( const Ipp64f *pTaps,
                                                 IppsIIRState64f_32s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps64fc_32sc,( const Ipp64fc *pTaps,
                                               IppsIIRState64fc_32sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsIIRSetTaps64f_16s,( const Ipp64f *pTaps,
                                                 IppsIIRState64f_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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;

struct FIRSpec_32f;
typedef struct FIRSpec_32f IppsFIRSpec_32f;

struct FIRSpec_64f;
typedef struct FIRSpec_64f IppsFIRSpec_64f;

struct FIRSpec_32fc;
typedef struct FIRSpec_32fc IppsFIRSpec_32fc;

struct FIRSpec_64fc;
typedef struct FIRSpec_64fc IppsFIRSpec_64fc;

#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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc_32f, (IppsFIRState_32f** pState,
        const Ipp32f* pTaps, int tapsLen, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc_32f, (IppsFIRState_32f** pState,
        const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc_32fc, (IppsFIRState_32fc** pState,
        const Ipp32fc* pTaps, int tapsLen, const Ipp32fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc_32fc, (IppsFIRState_32fc** pState,
        const Ipp32fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32f_16s, (IppsFIRState32f_16s** pState,
        const Ipp32f* pTaps, int tapsLen, const Ipp16s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc32f_16s, (IppsFIRState32f_16s** pState,
        const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32fc_16sc, (IppsFIRState32fc_16sc** pState,
        const Ipp32fc* pTaps, int tapsLen, const Ipp16sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc32fc_16sc, (IppsFIRState32fc_16sc** pState,
        const Ipp32fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16sc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc_64f, (IppsFIRState_64f** pState,
        const Ipp64f* pTaps, int tapsLen, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc_64f, (IppsFIRState_64f** pState,
        const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp64f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc_64fc, (IppsFIRState_64fc** pState,
        const Ipp64fc* pTaps, int tapsLen, const Ipp64fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc_64fc, (IppsFIRState_64fc** pState,
        const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp64fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64f_32f, (IppsFIRState64f_32f** pState,
        const Ipp64f* pTaps, int tapsLen, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_32f, (IppsFIRState64f_32f** pState,
        const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32f* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_32fc, (IppsFIRState64fc_32fc** pState,
        const Ipp64fc* pTaps, int tapsLen, const Ipp32fc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_32fc, (IppsFIRState64fc_32fc** pState,
        const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32fc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64f_32s, (IppsFIRState64f_32s** pState,
        const Ipp64f* pTaps, int tapsLen, const Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_32s, (IppsFIRState64f_32s** pState,
        const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_32sc, (IppsFIRState64fc_32sc** pState,
        const Ipp64fc* pTaps, int tapsLen, const Ipp32sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_32sc, (IppsFIRState64fc_32sc** pState,
        const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp32sc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64f_16s, (IppsFIRState64f_16s** pState,
        const Ipp64f* pTaps, int tapsLen, const Ipp16s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64f_16s, (IppsFIRState64f_16s** pState,
        const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16s* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc64fc_16sc, (IppsFIRState64fc_16sc** pState,
        const Ipp64fc* pTaps, int tapsLen, const Ipp16sc* pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc64fc_16sc, (IppsFIRState64fc_16sc** pState,
        const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16sc* pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree_32f, (IppsFIRState_32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree_32fc, (IppsFIRState_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree32f_16s, (IppsFIRState32f_16s* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree32fc_16sc, (IppsFIRState32fc_16sc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree_64f, (IppsFIRState_64f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree_64fc, (IppsFIRState_64fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree64f_32f, (IppsFIRState64f_32f* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree64fc_32fc, (IppsFIRState64fc_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree64f_32s, (IppsFIRState64f_32s* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree64fc_32sc, (IppsFIRState64fc_32sc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree64f_16s, (IppsFIRState64f_16s* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRGetStateSize32sc_16sc32fc,( int tapsLen,
                                                            int *pStateSize ))
/* ****************************** 32s_16s32f ******************************* */
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRGetStateSize32s_16s32f,( int tapsLen,
                                                            int* pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRInit32s_16s32f,( IppsFIRState32s_16s** ppState,
      const Ipp32f *pTaps, int tapsLen, const Ipp16s *pDlyLine, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRGetStateSize32s_16s32f,( int tapsLen, int upFactor,
                                            int downFactor, int *pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRInit32sc_16sc32fc,( IppsFIRState32sc_16sc** ppState,
    const Ipp32fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine, Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRGetStateSize32sc_16sc32fc,( int tapsLen,
                              int upFactor, int downFactor, int *pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps_32f, (const IppsFIRState_32f* pState, Ipp32f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps_32fc, (const IppsFIRState_32fc* pState, Ipp32fc* pTaps))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps32f_16s, (const IppsFIRState32f_16s* pState, Ipp32f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps32fc_16sc, (const IppsFIRState32fc_16sc* pState, Ipp32fc* pTaps))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps_64f, (const IppsFIRState_64f* pState, Ipp64f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps_64fc, (const IppsFIRState_64fc* pState, Ipp64fc* pTaps))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps64f_32f, (const IppsFIRState64f_32f* pState, Ipp64f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps64fc_32fc, (const IppsFIRState64fc_32fc* pState, Ipp64fc* pTaps))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps64f_32s, (const IppsFIRState64f_32s* pState, Ipp64f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps64fc_32sc, (const IppsFIRState64fc_32sc* pState, Ipp64fc* pTaps))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps64f_16s, (const IppsFIRState64f_16s* pState, Ipp64f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_32f,( const Ipp32f *pTaps,
                                                    IppsFIRState_32f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_32fc,( const Ipp32fc *pTaps,
                                                   IppsFIRState_32fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32f_16s,( const Ipp32f *pTaps,
                                                 IppsFIRState32f_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32fc_16sc,( const Ipp32fc *pTaps,
                                               IppsFIRState32fc_16sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32s_16s,( const Ipp32s *pTaps,
                                 IppsFIRState32s_16s* pState, int tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32sc_16sc,( const Ipp32sc *pTaps,
                               IppsFIRState32sc_16sc* pState, int tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32s_16s32f,( const Ipp32f *pTaps,
                                                 IppsFIRState32s_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps32sc_16sc32fc,( const Ipp32fc *pTaps,
                                               IppsFIRState32sc_16sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_64f,( const Ipp64f *pTaps,
                                                    IppsFIRState_64f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_64fc,( const Ipp64fc *pTaps,
                                                   IppsFIRState_64fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps64f_32f,( const Ipp64f *pTaps,
                                                 IppsFIRState64f_32f* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps64fc_32fc,( const Ipp64fc *pTaps,
                                               IppsFIRState64fc_32fc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps64f_32s,( const Ipp64f *pTaps,
                                                 IppsFIRState64f_32s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps64fc_32sc,( const Ipp64fc *pTaps,
                                               IppsFIRState64fc_32sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps64f_16s,( const Ipp64f *pTaps,
                                                 IppsFIRState64f_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use Init function instead of SetTaps for changing filter coefficients. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_32f, (Ipp32f src, Ipp32f* pDstVal, IppsFIRState_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsFIRState_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
        IppsFIRState32f_16s* pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32fc_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal,
        IppsFIRState32fc_16sc* pState,  int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_64f, (Ipp64f src, Ipp64f* pDstVal, IppsFIRState_64f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_64fc, (Ipp64fc src, Ipp64fc* pDstVal, IppsFIRState_64fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_32f, (Ipp32f src, Ipp32f* pDstVal, IppsFIRState64f_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_32fc, (Ipp32fc src, Ipp32fc* pDstVal, IppsFIRState64fc_32fc* pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal,
        IppsFIRState64f_32s* pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal,
        IppsFIRState64fc_32sc* pState,  int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
        IppsFIRState64f_16s* pState,  int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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);
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32s_16s, (IppsFIRState32s_16s** pState,
        const Ipp32s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32s_16s32f, (IppsFIRState32s_16s** pState,
        const Ipp32f *pTaps, int tapsLen, const Ipp16s *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc32s_16s32f, (IppsFIRState32s_16s **pState,
        const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16s *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32sc_16sc, (IppsFIRState32sc_16sc** pState,
        const Ipp32sc *pTaps, int tapsLen, int tapsFactor, const Ipp16sc *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc32sc_16sc32fc, (IppsFIRState32sc_16sc** pState,
        const Ipp32fc *pTaps, int tapsLen, const Ipp16sc *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRMRInitAlloc32sc_16sc32fc, (IppsFIRState32sc_16sc** pState,
        const Ipp32fc *pTaps, int tapsLen, int upFactor, int upPhase,
        int downFactor, int downPhase, const Ipp16sc *pDlyLine))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRFree32s_16s, (IppsFIRState32s_16s *pState))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps32s_16s, (const IppsFIRState32s_16s* pState,
        Ipp32s* pTaps, int* tapsFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps32sc_16sc, (const IppsFIRState32sc_16sc* pState,
        Ipp32sc* pTaps, int* tapsFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRGetTaps32s_16s32f, (const IppsFIRState32s_16s* pState,
        Ipp32f* pTaps))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32s_16s_Sfs, (Ipp16s src, Ipp16s *pDstVal,
        IppsFIRState32s_16s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsFIR32s_16s_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32s_16s_ISfs, (Ipp16s *pSrcDst, int numIters,
        IppsFIRState32s_16s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Replace with ippsFIR32sc_16sc_Sfs. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32sc_16sc_ISfs, (Ipp16sc *pSrcDst, int numIters,
        IppsFIRState32sc_16sc *pState, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRInitAlloc_32s,( IppsFIRState_32s** pState,
                   const Ipp32s *pTaps, int tapsLen, const Ipp32s *pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRGetStateSize_32s,( int tapsLen, int* pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRInit_32s,( IppsFIRState_32s** pState,
      const Ipp32s *pTaps, int tapsLen, const Ipp32s *pDlyLine, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_32s,( const Ipp32s *pTaps,
                                                   IppsFIRState_32s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRGetTaps_32s,( const IppsFIRState_32s* pState,
                                                              Ipp32s* pTaps ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIROne_32s_Sfs,( Ipp32s src, Ipp32s *pDstVal,
                                  IppsFIRState_32s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIR_32s_Sfs,( const Ipp32s *pSrc, Ipp32s *pDst,
                    int numIters, IppsFIRState_32s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIR_32s_ISfs,( Ipp32s *pSrcDst, int numIters,
                                  IppsFIRState_32s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRFree_32s,( IppsFIRState_32s *pState ))

IPPAPI( IppStatus, ippsFIRGetStateSize_16s,( int tapsLen, int* pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRGetStateSize_16s,( int tapsLen, int upFactor,
                                            int downFactor, int *pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRInit_16s,( IppsFIRState_16s** ppState,
      const Ipp16s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine,
                                                            Ipp8u* pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRInitAlloc_16s, (IppsFIRState_16s** pState,
        const Ipp16s *pTaps, int tapsLen, int tapsFactor, const Ipp16s *pDlyLine))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetTaps_16s,( const Ipp16s *pTaps,
                                 IppsFIRState_16s* pState, int tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRGetTaps_16s,( const IppsFIRState_16s* pState,
                                              Ipp16s* pTaps, int* tapsFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRSetDlyLine_16s,( IppsFIRState_16s *pState,
                                                      const Ipp16s *pDlyLine ))
IPPAPI( IppStatus, ippsFIRGetDlyLine_16s,(
                         const IppsFIRState_16s *pState, Ipp16s *pDlyLine ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use vector function with vector length = 1 instead. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIROne_16s_Sfs,( Ipp16s src, Ipp16s *pDstVal,
                               IppsFIRState_16s *pState,  int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_16s_Sfs, (const Ipp16s *pSrc, Ipp16s *pDst,
        int numIters, IppsFIRState_16s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIR_16s_ISfs,( Ipp16s *pSrcDst, int numIters,
                                IppsFIRState_16s *pState, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRStreamGetStateSize_16s,( int tapsLen, int* pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_16s,( int tapsLen, int upFactor,
                                            int downFactor, int *pStateSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRStreamInit_16s,( IppsFIRState_16s** pState,
      const Ipp16s *pTaps, int tapsLen, int tapsFactor,  IppRoundMode rndMode, Ipp8u* pBuf ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRStreamInitAlloc_16s, (IppsFIRState_16s** pState,
        const Ipp16s *pTaps, int tapsLen, int tapsFactor, IppRoundMode rndMode))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRStreamGetStateSize_32f,( int tapsLen, int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_32f,( int tapsLen, int upFactor,
                                             int downFactor, int *pBufferSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRStreamInit_32f,( IppsFIRState_32f** pState,
    const Ipp32f *pTaps, int tapsLen, Ipp8u *pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRMRStreamInit_32f,( IppsFIRState_32f** pState,
    const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,
                  int downFactor, int downPhase, Ipp8u *pBuffer ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRStreamInitAlloc_32f,( IppsFIRState_32f** pState,
                    const Ipp32f *pTaps, int tapsLen ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRLMSOne_Direct_32f,( Ipp32f src, Ipp32f refval,
       Ipp32f* pDstVal, Ipp32f* pTapsInv, int tapsLen, float mu, Ipp32f* pDlyLine,
       int* pDlyIndex ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRLMSOne_Direct32f_16s,( Ipp16s src, Ipp16s refval,
       Ipp16s* pDstVal, Ipp32f* pTapsInv, int tapsLen, float mu, Ipp16s* pDlyLine,
       int* pDlyIndex ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRLMSInitAlloc_32f,( IppsFIRLMSState_32f** pState,
   const Ipp32f* pTaps, int tapsLen, const Ipp32f* pDlyLine, int dlyLineIndex ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRLMSInitAlloc32f_16s,( IppsFIRLMSState32f_16s** pState,
   const Ipp32f* pTaps, int tapsLen, const Ipp16s* pDlyLine, int dlyLineIndex ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIRLMSFree_32f,( IppsFIRLMSState_32f* pState))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Internal memory allocation will not be supported - use Get<Buffer>Size and Init pair for this functionality. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMROne32s_16s,( Ipp32s* pDstVal,
                                            IppsFIRLMSMRState32s_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMROneVal32s_16s,( Ipp16s val, Ipp32s* pDstVal,
                                            IppsFIRLMSMRState32s_16s* pState ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMROne32sc_16sc,( Ipp32sc* pDstVal,
                                            IppsFIRLMSMRState32sc_16sc* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRInitAlloc32s_16s,( IppsFIRLMSMRState32s_16s** pState,
   const Ipp32s* pTaps, int tapsLen, const Ipp16s* pDlyLine, int dlyLineIndex,
   int dlyStep, int updateDly, int mu ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRFree32s_16s,( IppsFIRLMSMRState32s_16s* pState ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRInitAlloc32sc_16sc,( IppsFIRLMSMRState32sc_16sc** pState,
   const Ipp32sc* pTaps, int tapsLen, const Ipp16sc* pDlyLine, int dlyLineIndex,
   int dlyStep, int updateDly, int mu ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRSetTaps32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                        const Ipp32s* pInTaps ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetTaps32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                           Ipp32s* pOutTaps ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetTapsPointer32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                           Ipp32s** pTaps ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRSetTaps32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
                                        const Ipp32sc* pInTaps ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetTaps32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
                                           Ipp32sc* pOutTaps ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRSetDlyLine32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                        const Ipp16s* pInDlyLine, int dlyLineIndex ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyLine32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                        Ipp16s* pOutDlyLine, int* pOutDlyIndex ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyVal32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                        Ipp16s* pOutVal, int index ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRSetDlyLine32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
                                        const Ipp16sc* pInDlyLine, int dlyLineIndex ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRGetDlyLine32sc_16sc,( IppsFIRLMSMRState32sc_16sc* pState,
                                        Ipp16sc* pOutDlyLine, int* pOutDlyLineIndex ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRPutVal32s_16s,( Ipp16s val,
                                            IppsFIRLMSMRState32s_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRSetMu32s_16s,( IppsFIRLMSMRState32s_16s* pState,
                                           const int mu ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIRLMSMRUpdateTaps32s_16s,( Ipp32s ErrVal,
                                            IppsFIRLMSMRState32s_16s* pState ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_32f, (Ipp32f src, Ipp32f* pDstVal, const Ipp32f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_32fc, (Ipp32fc src, Ipp32fc* pDstVal, const Ipp32fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_32f_I, (Ipp32f* pSrcDstVal, const Ipp32f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_32fc_I, (Ipp32fc* pSrcDstVal, const Ipp32fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32f_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, const Ipp32f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32fc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, const Ipp32fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32f_Direct_16s_ISfs, (Ipp16s* pSrcDstVal, const Ipp32f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDstVal, const Ipp32fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_64f, (Ipp64f src, Ipp64f* pDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp64f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_64fc, (Ipp64fc src, Ipp64fc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp64fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_64f_I, (Ipp64f* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp64f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne_Direct_64fc_I, (Ipp64fc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp64fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_32f, (Ipp32f src, Ipp32f* pDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32fc, (Ipp32fc src, Ipp32fc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_32f_I, (Ipp32f* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32fc_I, (Ipp32fc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_32s_Sfs, (Ipp32s src, Ipp32s* pDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32sc_Sfs, (Ipp32sc src, Ipp32sc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_32s_ISfs, (Ipp32s* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_32sc_ISfs, (Ipp32sc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64f_Direct_16s_ISfs, (Ipp16s* pSrcDstVal, const Ipp64f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne64fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDstVal, const Ipp64fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32s_Direct_16s_Sfs, (Ipp16s src, Ipp16s* pDstVal,
        const Ipp32s* pTaps, int tapsLen, int tapsFactor,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32sc_Direct_16sc_Sfs, (Ipp16sc src, Ipp16sc* pDstVal,
        const Ipp32sc* pTaps, int tapsLen, int tapsFactor,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIROne32s_Direct_16s_ISfs, (Ipp16s* pSrcDstVal,
        const Ipp32s* pTaps, int tapsLen, int tapsFactor,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters, const Ipp32f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_32f_I, (Ipp32f* pSrcDst, int numIters, const Ipp32f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters, const Ipp32f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters, const Ipp32f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters, const Ipp32fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_64f, (const Ipp64f* pSrc, Ipp64f* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp64f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp64fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_64f_I, (Ipp64f* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp64f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR_Direct_64fc_I, (Ipp64fc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp64fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_32f, (const Ipp32f* pSrc, Ipp32f* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_32f_I, (Ipp32f* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp32f* pDlyLine, int* pDlyLineIndex))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_32fc_I, (Ipp32fc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp32fc* pDlyLine, int* pDlyLineIndex))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_32s_Sfs, (const Ipp32s* pSrc, Ipp32s* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_32sc_Sfs, (const Ipp32sc* pSrc, Ipp32sc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_32s_ISfs, (Ipp32s* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp32s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_32sc_ISfs, (Ipp32sc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp32sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_16s_Sfs, (const Ipp16s* pSrc, Ipp16s* pDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_16sc_Sfs, (const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64f_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters, const Ipp64f* pTaps, int tapsLen,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR64fc_Direct_16sc_ISfs, (Ipp16sc* pSrcDst, int numIters, const Ipp64fc* pTaps, int tapsLen,
        Ipp16sc* pDlyLine, int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsFIR32s_Direct_16s_ISfs, (Ipp16s* pSrcDst, int numIters,
        const Ipp32s* pTaps, int tapsLen, int tapsFactor,
        Ipp16s* pDlyLine, int* pDlyLineIndex, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/


IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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.
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIR_Direct_16s_Sfs,( const Ipp16s* pSrc, Ipp16s* pDst,
          int numIters, const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
                                      int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIR_Direct_16s_ISfs,( Ipp16s* pSrcDst, int numIters,
                       const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
                                      int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI( IppStatus, ippsFIROne_Direct_16s_Sfs,( Ipp16s src, Ipp16s* pDstVal,
                       const Ipp16s* pTapsQ15, int tapsLen, Ipp16s* pDlyLine,
                                      int* pDlyLineIndex, int scaleFactor ))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases.  Use FIR function with State structure instead of this one. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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)))
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s_ISfs, (Ipp16s* pSrcDst, int len,
                                             int alphaQ15, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s_I, (Ipp16s* pSrcDst, int len, int alphaQ15))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsWinBlackmanQ15_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, int alphaQ15))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsWinKaiserQ15_16s, (const Ipp16s* pSrc, Ipp16s* pDst, int len, int alphaQ15))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsWinKaiserQ15_16sc,(const Ipp16sc* pSrc, Ipp16sc* pDst, int len, int alphaQ15))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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, Ipp64f alpha))
IPPAPI(IppStatus, ippsWinKaiser_64f_I,  (Ipp64f* pSrcDst, int len, Ipp64f alpha))
IPPAPI(IppStatus, ippsWinKaiser_64fc_I, (Ipp64fc* pSrcDst, int len, Ipp64f alpha))
IPPAPI(IppStatus, ippsWinKaiser_64fc,   (const Ipp64fc* pSrc, Ipp64fc* pDst, int len, Ipp64f 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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Names:  ippsCrossCorrNormGetBufferSize
//
//  Purpose:     Get the size (in bytes) of the buffer for ippsCrossCorrNorm's internal calculations.
//
//  Parameters:
//    src1Len     - Length of the first source vector.
//    src2Len     - Length of the second source vector.
//    dstLen      - Length of cross-correlation.
//    lowLag      - Cross-correlation lowest lag.
//    dataType    - Data type for convolution {Ipp32f|Ipp32fc|Ipp64f|Ipp64fc}.
//    algType     - Selector for the algorithm type. Possible values are the results of composition
//                  of the  IppAlgType and IppsNormOp values.
//    pBufferSize - Pointer to the calculated buffer size (in bytes).
//  Return:
//    ippStsNoErr       - OK.
//    ippStsNullPtrErr  - pBufferSize is NULL.
//    ippStsSizeErr     - Vector's length is not positive.
//    ippStsDataTypeErr - Unsupported data type.
//    ippStsAlgTypeErr  - Unsupported algorithm or normalization type.
*/

IPPAPI(IppStatus, ippsCrossCorrNormGetBufferSize, ( int src1Len, int src2Len, int dstLen, int lowLag, IppDataType dataType, IppEnum algType, int* pBufferSize ))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCrossCorrNorm_32f, ippsCrossCorrNorm_32fc
//              ippsCrossCorrNorm_64f, ippsCrossCorrNorm_64fc
//
//  Purpose:    Calculate the cross-correlation of two vectors.
//
//  Parameters:
//     pSrc1   - Pointer to the first source vector.
//     src1Len - Length of the first source vector.
//     pSrc2   - Pointer to the second source vector.
//     src2Len - Length of the second source vector.
//     pDst    - Pointer to the cross correlation.
//     dstLen  - Length of the cross-correlation.
//     lowLag  - Cross-correlation lowest lag.
//     algType - Selector for the algorithm type. Possible values are the results of composition
//               of the  IppAlgType and IppsNormOp values.
//     pBuffer - Pointer to the buffer for internal calculations.
//  Return:
//    ippStsNoErr      - OK.
//    ippStsNullPtrErr - One of the pointers is NULL.
//    ippStsSizeErr    - Vector's length is not positive.
//    ippStsAlgTypeErr - Unsupported algorithm or normalization type.
*/

IPPAPI(IppStatus, ippsCrossCorrNorm_32f, (const Ipp32f*  pSrc1, int src1Len, const Ipp32f*  pSrc2, int src2Len, Ipp32f*  pDst,  int dstLen, int lowLag, IppEnum algType, Ipp8u* pBuffer))
IPPAPI(IppStatus, ippsCrossCorrNorm_64f, (const Ipp64f*  pSrc1, int src1Len, const Ipp64f*  pSrc2, int src2Len, Ipp64f*  pDst,  int dstLen, int lowLag, IppEnum algType, Ipp8u* pBuffer))
IPPAPI(IppStatus, ippsCrossCorrNorm_32fc,(const Ipp32fc* pSrc1, int src1Len, const Ipp32fc* pSrc2, int src2Len, Ipp32fc* pDst,  int dstLen, int lowLag, IppEnum algType, Ipp8u* pBuffer))
IPPAPI(IppStatus, ippsCrossCorrNorm_64fc,(const Ipp64fc* pSrc1, int src1Len, const Ipp64fc* pSrc2, int src2Len, Ipp64fc* pDst,  int dstLen, int lowLag, IppEnum algType, Ipp8u* pBuffer))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCrossCorr_32f,  ippsCrossCorr_64f,
//              ippsCrossCorr_32fc, ippsCrossCorr_64fc
//
//  Purpose:    Calculate the cross-correlation of two vectors.
//
//  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
//
*/

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsCrossCorrNorm_32f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCrossCorr_32f, (const Ipp32f* pSrc1, int src1Len, const Ipp32f* pSrc2, int src2Len, Ipp32f* pDst,  int dstLen, int lowLag))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsCrossCorrNorm_64f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCrossCorr_64f, (const Ipp64f* pSrc1, int src1Len, const Ipp64f* pSrc2, int src2Len, Ipp64f* pDst,  int dstLen, int lowLag))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsCrossCorrNorm_32fc with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCrossCorr_32fc,(const Ipp32fc* pSrc1, int src1Len, const Ipp32fc* pSrc2, int src2Len, Ipp32fc* pDst,  int dstLen, int lowLag))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsCrossCorrNorm_64fc with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
//
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsConvert_16s32f and ippsCrossCorrNorm_32f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCrossCorr_16s_Sfs, (const Ipp16s* pSrc1, int src1Len, const Ipp16s* pSrc2, int src2Len,
                                                   Ipp16s* pDst, int dstLen, int lowLag, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCrossCorr_16s64s, (const Ipp16s* pSrc1, int src1Len, const Ipp16s* pSrc2, int src2Len,
                                                                    Ipp64s* pDst, int dstLen, int lowLag))
/* /////////////////////////////////////////////////////////////////////////////
//                AutoCorrelation Functions
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Names:  ippsAutoCorrNormGetBufferSize
//
//  Purpose:     : Get the size (in bytes) of the buffer for ippsAutoCorrNorm's internal calculations.
//
//  Parameters:
//     srcLen      - Source vector length.
//     dstLen      - Length of auto-correlation.
//     dataType    - Data type for auto corelation {Ipp32f|Ipp32fc|Ipp64f|Ipp64fc}.
//     algType     - Selector for the algorithm type.  Possible values are the results of
//                   composition of the IppAlgType and IppsNormOp values.
//     pBufferSize - Pointer to the calculated buffer size (in bytes).
//  Return:
//   ippStsNoErr       - OK.
//   ippStsNullPtrErr  - pBufferSize is NULL.
//   ippStsSizeErr     - Vector's length is not positive.
//   ippStsDataTypeErr - Unsupported data type.
//   ippStsAlgTypeErr  - Unsupported algorithm or normalization type.
*/

IPPAPI(IppStatus, ippsAutoCorrNormGetBufferSize, ( int srcLen, int dstLen, IppDataType dataType, IppEnum algType, int* pBufferSize ))


/* /////////////////////////////////////////////////////////////////////////////
//  Names:  ippsAutoCorrNorm_32f,  ippsAutoCorrNorm_64f
//          ippsAutoCorrNorm_32fc,  ippsAutoCorrNorm_64fc
//
//  Purpose:    Calculate the auto-correlation,
//              ippNormNone specifies the normal auto-correlation.
//              ippNormA specifies the biased auto-correlation
//              (the resulting values are divided by srcLen).
//              ippNormB specifies the unbiased auto-correlation
//              (the resulting values are divided by ( srcLen - n ),
//              where "n" indicates current iteration).
//
//  Parameters:
//     pSrc    - Pointer to the source vector.
//     srcLen  - Source vector length.
//     pDst    - Pointer to the auto-correlation result vector.
//     dstLen  - Length of auto-correlation.
//     algType - Selector for the algorithm type. Possible values are the results
//               of composition of the  IppAlgType and IppsNormOp values.
//     pBuffer - Pointer to the buffer for internal calculations.
//  Return:
//   ippStsNoErr      - OK.
//   ippStsNullPtrErr - One of the pointers is NULL.
//   ippStsSizeErr    - Vector's length is not positive.
//   ippStsAlgTypeErr - Unsupported algorithm or normalization type.
*/

IPPAPI(IppStatus, ippsAutoCorrNorm_32f , ( const Ipp32f*  pSrc, int srcLen, Ipp32f*  pDst, int dstLen, IppEnum algType, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsAutoCorrNorm_64f , ( const Ipp64f*  pSrc, int srcLen, Ipp64f*  pDst, int dstLen, IppEnum algType, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsAutoCorrNorm_32fc, ( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen, IppEnum algType, Ipp8u* pBuffer ))
IPPAPI(IppStatus, ippsAutoCorrNorm_64fc, ( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen, IppEnum algType, Ipp8u* pBuffer ))



/* /////////////////////////////////////////////////////////////////////////////
//  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
*/

IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32f with algType=ippsNormA instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormA_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32f with algType=ippsNormB instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormB_32f, ( const Ipp32f* pSrc, int srcLen, Ipp32f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64f with algType=ippsNormA instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormA_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64f with algType=ippsNormB instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormB_64f, ( const Ipp64f* pSrc, int srcLen, Ipp64f* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32fc with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32fc with algType=ippsNormA instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormA_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_32fc with algType=ippsNormB instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormB_32fc,( const Ipp32fc* pSrc, int srcLen, Ipp32fc* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64fc with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_64fc,( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64fc with algType=ippsNormA instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormA_64fc,( const Ipp64fc* pSrc, int srcLen, Ipp64fc* pDst, int dstLen ))
IPP_DEPRECATED("is deprecated. Removal 2H 2014 or later. Use ippsAutoCorrNorm_64fc with algType=ippsNormB instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsConvert_16s32f and ippsAutoCorrNorm_32f with algType=ippsNormNone instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_16s_Sfs,( const Ipp16s* pSrc, int srcLen, Ipp16s* pDst, int dstLen, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsConvert_16s32f and ippsAutoCorrNorm_32f with algType=ippsNormA instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsAutoCorr_NormA_16s_Sfs,( const Ipp16s* pSrc, int srcLen, Ipp16s* pDst, int dstLen, int scaleFactor ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use ippsConvert_16s32f and ippsAutoCorrNorm_32f with algType=ippsNormB instead. For more details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbertInitAlloc_32f32fc, (IppsHilbertSpec_32f32fc **pSpec,
                                                 int length, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbertInitAlloc_16s32fc, (IppsHilbertSpec_16s32fc **pSpec,
                                                 int length, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbertInitAlloc_16s16sc, (IppsHilbertSpec_16s16sc **pSpec,
                                                 int length, IppHintAlgorithm hint))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbertFree_32f32fc, (IppsHilbertSpec_32f32fc *pSpec))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbertFree_16s32fc, (IppsHilbertSpec_16s32fc *pSpec))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbert_32f32fc, (const Ipp32f *pSrc, Ipp32fc *pDst,
                                        IppsHilbertSpec_32f32fc *pSpec))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsHilbert_16s32fc, (const Ipp16s *pSrc, Ipp32fc *pDst,
                                        IppsHilbertSpec_16s32fc *pSpec))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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:         ippsFIRSparseSetDlyLine_32f
//                 ippsFIRSparseGetDlyLine_32f
//  Purpose:       Get(set) delay line
//  Parameters:
//      pState      - pointer to the filter state
//      pDlyLine    - pointer to the delay line values, can be NULL;
//  Return:
//      ippStsNullPtrErr       - pointer(s) to the data is NULL
*/

IPPAPI(IppStatus, ippsFIRSparseSetDlyLine_32f,( IppsFIRSparseState_32f* pState, const Ipp32f* pDlyLine ))
IPPAPI(IppStatus, ippsFIRSparseGetDlyLine_32f,( const IppsFIRSparseState_32f* pState, Ipp32f* pDlyLine ))
/* /////////////////////////////////////////////////////////////////////////////
//  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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus,ippsSumWindow_8u32f ,(const Ipp8u*  pSrc,Ipp32f* pDst,int len, int maskSize ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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 ))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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]
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDiv_Round_8u_Sfs, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
       Ipp8u* pDst, int len, IppRoundMode rndMode, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDiv_Round_16s_Sfs, (const Ipp16s* pSrc1, const Ipp16s* pSrc2,
       Ipp16s* pDst, int len, IppRoundMode rndMode, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDiv_Round_16u_Sfs, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
       Ipp16u* pDst, int len, IppRoundMode rndMode, int scaleFactor))

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDiv_Round_8u_ISfs, (const Ipp8u* pSrc, Ipp8u* pSrcDst,
       int len, IppRoundMode rndMode, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsDiv_Round_16s_ISfs, (const Ipp16s* pSrc, Ipp16s* pSrcDst,
       int len, IppRoundMode rndMode, int scaleFactor))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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
*/

IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCauchy_32f_I, (Ipp32f* pSrcDst, int len, Ipp32f C))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
IPPAPI(IppStatus, ippsCauchyD_32f_I, (Ipp32f* pSrcDst, int len, Ipp32f C))
IPP_DEPRECATED("is deprecated. This function is obsolete and will be removed in one of the future IPP releases. Use the following link for details: https://software.intel.com/sites/products/ipp-deprecated-features-feedback/")\
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))

/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
#if !defined( _OWN_BLDPCS )
struct ResamplingPolyphase_16s;
struct ResamplingPolyphaseFixed_16s;
struct ResamplingPolyphase_32f;
struct ResamplingPolyphaseFixed_32f;

typedef struct ResamplingPolyphase_16s IppsResamplingPolyphase_16s;
typedef struct ResamplingPolyphaseFixed_16s IppsResamplingPolyphaseFixed_16s;
typedef struct ResamplingPolyphase_32f IppsResamplingPolyphase_32f;
typedef struct ResamplingPolyphaseFixed_32f IppsResamplingPolyphaseFixed_32f;

#define IppsResamlingPolyphase_16s IppsResamplingPolyphase_16s
#define IppsResamlingPolyphaseFixed_16s IppsResamplingPolyphaseFixed_16s
#define IppsResamlingPolyphase_32f IppsResamplingPolyphase_32f
#define IppsResamlingPolyphaseFixed_32f IppsResamplingPolyphaseFixed_32f
#endif

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphase, ippsResamplePolyphaseFixed
//  Purpose:        Resample input data.
//   Arguments:
//      pSrc      The pointer to the input vector.
//      pDst      The pointer to the output vector.
//      len       The number of input vector elements to resample.
//      norm      The norming factor for output samples.
//      factor    The resampling factor.
//      pTime     The pointer to the start time of resampling (in input vector elements).
//      pOutlen   The number of calculated output vector elements
//      pSpec     The pointer to the resampling specification structure.
//   Return Value
//      ippStsNoErr        Indicates no error.
//      ippStsNullPtrErr   Indicates an error when pSpec, pSrc, pDst, pTime or pOutlen is NULL.
//      ippStsSizeErr      Indicates an error when len is less than or equal to 0.
//      ippStsBadArgErr    Indicates an error when factor is less than or equal to.
*/

IPPAPI(IppStatus, ippsResamplePolyphase_16s,(const Ipp16s *pSrc, int len,
                                  Ipp16s *pDst, Ipp64f factor, Ipp32f norm, Ipp64f *pTime,
                                  int *pOutlen, const IppsResamplingPolyphase_16s *pSpec))

IPPAPI(IppStatus,  ippsResamplePolyphase_32f,(const Ipp32f *pSrc, int len,
                                  Ipp32f *pDst, Ipp64f factor, Ipp32f norm, Ipp64f *pTime,
                                  int *pOutlen, const IppsResamplingPolyphase_32f *pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseFixed_16s,(const Ipp16s *pSrc, int len, Ipp16s *pDst,
                                       Ipp32f norm, Ipp64f *pTime, int *pOutlen,
                                       const IppsResamplingPolyphaseFixed_16s *pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseFixed_32f,(const Ipp32f *pSrc, int len, Ipp32f *pDst,
                                       Ipp32f norm, Ipp64f *pTime, int *pOutlen,
                                       const IppsResamplingPolyphaseFixed_32f *pSpec))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseGetSize, ippsResamplePolyphaseFixedGetSize
//  Purpose:        Determines the size required for the ResamplePolyphase or ResamplePolyphaseFixed.
//   Arguments:
//      window          The size of the ideal lowpass filter window.
//      nStep           The discretization step for filter coefficients
//      inRate          The input rate for resampling with fixed factor.
//      outRate         The output rate for resampling with fixed factor.
//      len             The filter length for resampling with fixed factor.
//      pSize           Required size in bytes
//      pLen            Filter len
//      pHeight         Number of filter
//      hint            Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
//
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSize, pLen or pHeight are NULL.
//      ippStsSizeErr     Indicates an error when inRate, outRate or len is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseGetSize_16s,(Ipp32f window, int nStep, int* pSize, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseGetSize_32f,(Ipp32f window, int nStep, int* pSize, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseFixedGetSize_16s,(int inRate, int outRate, int
       len, int* pSize, int* pLen, int* pHeight, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseFixedGetSize_32f,(int inRate, int outRate, int
       len, int* pSize, int* pLen, int* pHeight, IppHintAlgorithm hint))


/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseInit, ippsResamplePolyphaseFixedInit
//  Purpose:        Initializes ResamplePolyphase of ResamplePolyphaseFixed structures
//   Arguments:
//      window          The size of the ideal lowpass filter window.
//      nStep           The discretization step for filter coefficients
//      inRate          The input rate for resampling with fixed factor.
//      outRate         The output rate for resampling with fixed factor.
//      len             The filter length for resampling with fixed factor.
//      rollf           The roll-off frequency of the filter.
//      alpha           The parameter of the Kaiser window.
//      pSpec           The pointer to the resampling specification structure to be created.
//      hint            Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec is NULL.
//      ippStsSizeErr     Indicates an error when inRate, outRate or len is less than or equal to 0.
//
*/
IPPAPI(IppStatus, ippsResamplePolyphaseInit_16s,(Ipp32f window, int nStep, Ipp32f rollf, Ipp32f alpha,
        IppsResamplingPolyphase_16s* pSpec, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseInit_32f,(Ipp32f window, int nStep, Ipp32f rollf, Ipp32f alpha,
        IppsResamplingPolyphase_32f* pSpec, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseFixedInit_16s,(int inRate, int outRate, int len, Ipp32f rollf, Ipp32f alpha,
        IppsResamplingPolyphaseFixed_16s* pSpec, IppHintAlgorithm hint))
IPPAPI(IppStatus, ippsResamplePolyphaseFixedInit_32f,(int inRate, int outRate, int len, Ipp32f rollf, Ipp32f alpha,
        IppsResamplingPolyphaseFixed_32f* pSpec, IppHintAlgorithm hint))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseSetFixedFilter
//  Purpose:        Set filter coefficient
//   Arguments:
//      pSpec           The pointer to the resampling specification structure to be created.
//      pSrc            Input vector of filter coefficients [height][step]
//      step            Lenght of filter
//      height          Number of filter
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec or pSrc are NULL.
//      ippStsSizeErr     Indicates an error when step or height is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseSetFixedFilter_16s,(const Ipp16s* pSrc, int step, int height,
            IppsResamplingPolyphaseFixed_16s* pSpec))

IPPAPI(IppStatus, ippsResamplePolyphaseSetFixedFilter_32f,(const Ipp32f* pSrc, int step, int height,
            IppsResamplingPolyphaseFixed_32f* pSpec))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:           ippsResamplePolyphaseGetFixedFilter
//  Purpose:        Get filter coefficient
//   Arguments:
//      pSpec           The pointer to the resampling specification structure to be created.
//      pDst            Input vector of filter coefficients [height][step]
//      step            Lenght of filter
//      height          Number of filter
//   Return Value
//      ippStsNoErr       Indicates no error.
//      ippStsNullPtrErr  Indicates an error when pSpec or pSrc are NULL.
//      ippStsSizeErr     Indicates an error when step or height is less than or equal to 0.
*/
IPPAPI(IppStatus, ippsResamplePolyphaseGetFixedFilter_16s,(Ipp16s* pDst, int step, int height,
        const IppsResamplingPolyphaseFixed_16s* pSpec))


IPPAPI(IppStatus, ippsResamplePolyphaseGetFixedFilter_32f,(Ipp32f* pDst, int step, int height,
        const IppsResamplingPolyphaseFixed_32f* pSpec))

/*FIR API New Design*/
/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsFIRSRGetSize, ippsFIRSRInit_32f, ippsFIRSRInit_64f
//                ippsFIRSR_32f, ippsFIRSR_64f
//  Purpose:      Get sizes of the FIR spec structure and temporary buffer
//                initialize FIR spec structure - set taps and delay line
//                perform FIR filtering
//                and close it
//  Parameters:
//      pTaps       - pointer to the filter coefficients
//      tapsLen     - number of coefficients
//      tapsType    - type of coefficients (ipp32f or ipp64f)
//      pSpecSize   - pointer to the size of FIR spec
//      pBufSize    - pointer to the size of temporal buffer
//      aType       - mask for the algorithm type definition (direct, fft, auto)
//      pDlySrc     - pointer to the input  delay line values, can be NULL
//      pDlyDst     - pointer to the output delay line values, can be NULL
//      pSpec       - pointer to the constant internal structure
//      pSrc        - pointer to the source vector.
//      pDst        - pointer to the destination vector
//      numIters    - length  of the destination vector
//      pBuf        - pointer to the work buffer
//   Return:
//      status      - status value returned, its value are
//         ippStsNullPtrErr       - one of the specified pointer is NULL
//         ippStsFIRLenErr        - tapsLen <= 0
//         ippStsContextMatchErr  - wrong state identifier
//         ippStsNoErr            - OK
//         ippStsSizeErr          - numIters is not positive
//         ippStsAlgTypeErr       - unsupported algorithm type
//         ippStsMismatch         - not effective algorithm.
*/

IPPAPI(IppStatus, ippsFIRSRGetSize, (int tapsLen,  IppDataType tapsType ,  int* pSpecSize,  int* pBufSize ))
IPPAPI(IppStatus, ippsFIRSRInit_32f,( const Ipp32f* pTaps, int tapsLen, IppAlgType aType, IppsFIRSpec_32f* pSpec ))
IPPAPI(IppStatus, ippsFIRSRInit_64f,( const Ipp64f* pTaps, int tapsLen, IppAlgType aType, IppsFIRSpec_64f* pSpec ))
IPPAPI(IppStatus, ippsFIRSRInit_32fc,( const Ipp32fc* pTaps, int tapsLen, IppAlgType aType, IppsFIRSpec_32fc* pSpec ))
IPPAPI(IppStatus, ippsFIRSRInit_64fc,( const Ipp64fc* pTaps, int tapsLen, IppAlgType aType, IppsFIRSpec_64fc* pSpec ))
IPPAPI(IppStatus, ippsFIRSR_32f,  (const Ipp32f*  pSrc, Ipp32f*  pDst, int numIters, IppsFIRSpec_32f*  pSpec, const Ipp32f*  pDlySrc, Ipp32f*  pDlyDst, Ipp8u* pBuf))
IPPAPI(IppStatus, ippsFIRSR_64f,  (const Ipp64f*  pSrc, Ipp64f*  pDst, int numIters, IppsFIRSpec_64f*  pSpec, const Ipp64f*  pDlySrc, Ipp64f*  pDlyDst, Ipp8u* pBuf))
IPPAPI(IppStatus, ippsFIRSR_32fc, (const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, IppsFIRSpec_32fc* pSpec, const Ipp32fc* pDlySrc, Ipp32fc* pDlyDst, Ipp8u* pBuf))
IPPAPI(IppStatus, ippsFIRSR_64fc, (const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters, IppsFIRSpec_64fc* pSpec, const Ipp64fc* pDlySrc, Ipp64fc* pDlyDst, Ipp8u* pBuf))
IPPAPI(IppStatus, ippsFIRSR_16s, ( const Ipp16s*  pSrc, Ipp16s*  pDst, int numIters, IppsFIRSpec_32f*  pSpec, const Ipp16s*  pDlySrc, Ipp16s*  pDlyDst, Ipp8u * pBuf))
IPPAPI(IppStatus, ippsFIRSR_16sc,( const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, IppsFIRSpec_32fc* pSpec, const Ipp16sc* pDlySrc, Ipp16sc* pDlyDst, Ipp8u * pBuf))

/* /////////////////////////////////////////////////////////////////////////////
//  Name:         ippsFIRMRGetSize,
//                ippsFIRMRInit_32f, ippsFIRMRInit_64f, ippsFIRMRInit_32fc, ippsFIRMRInit_64fc
//                ippsFIRMR_32f, ippsFIRMR_32fc, ippsFIRMR_64f, ippsFIRMR_64fc, ippsFIRMR_16s, ippsFIRMR_16sc,
//  Purpose:      Get sizes of the FIR spec structure and temporary buffer,
//                initialize FIR spec structure - set taps and delay line,
//                perform multi rate FIR filtering
//                
//  Parameters:
//      pTaps       - pointer to the filter coefficients
//      tapsLen     - number of coefficients
//      tapsType    - type of coefficients (ipp32f or ipp64f)
//      pSpecSize   - pointer to the size of FIR spec
//      pBufSize    - pointer to the size of temporal buffer
//      pDlySrc     - pointer to the input  delay line values, can be NULL
//      pDlyDst     - pointer to the output delay line values, can be NULL
//      upFactor    - multi-rate up factor;
//      upPhase     - multi-rate up phase;
//      downFactor  - multi-rate down factor;
//      downPhase   - multi-rate down phase;
//      pSpec       - pointer to the constant internal structure
//      pSrc        - pointer to the source vector.
//      pDst        - pointer to the destination vector
//      numIters    - length  of the destination vector
//      pBuf        - pointer to the work buffer
//   Return:
//      status      - status value returned, its value are
//         ippStsNullPtrErr       - one of the specified pointer is NULL
//         ippStsFIRLenErr        - tapsLen <= 0
//         ippStsFIRMRFactorErr   - factor <= 0
//         ippStsFIRMRPhaseErr    - phase < 0 || factor <= phase
//         ippStsContextMatchErr  - wrong state identifier
//         ippStsNoErr            - OK
//         ippStsSizeErr          - numIters is not positive
*/

IPPAPI(IppStatus, ippsFIRMRGetSize,   (                     int tapsLen, int upFactor,              int downFactor, IppDataType tapsType ,  int * pSpecSize,  int* pBufSize ))
IPPAPI(IppStatus, ippsFIRMR_Init_32f,(const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase, int downFactor, int downPhase,  IppsFIRSpec_32f* pSpec ))
IPPAPI(IppStatus, ippsFIRMR_Init_64f,(const Ipp64f* pTaps, int tapsLen, int upFactor, int upPhase, int downFactor, int downPhase,  IppsFIRSpec_64f* pSpec ))
IPPAPI(IppStatus, ippsFIRMR_Init_32fc,(const Ipp32fc* pTaps, int tapsLen, int upFactor, int upPhase, int downFactor, int downPhase,  IppsFIRSpec_32fc* pSpec ))
IPPAPI(IppStatus, ippsFIRMR_Init_64fc,(const Ipp64fc* pTaps, int tapsLen, int upFactor, int upPhase, int downFactor, int downPhase,  IppsFIRSpec_64fc* pSpec ))

IPPAPI(IppStatus, ippsFIRMR_32f, ( const Ipp32f* pSrc, Ipp32f* pDst, int numIters, IppsFIRSpec_32f* pSpec, const Ipp32f *pDlySrc,  Ipp32f *pDlyDst,  Ipp8u * pBuf))
IPPAPI(IppStatus, ippsFIRMR_64f, ( const Ipp64f* pSrc, Ipp64f* pDst, int numIters, IppsFIRSpec_64f* pSpec, const Ipp64f *pDlySrc,  Ipp64f *pDlyDst,  Ipp8u * pBuf))
IPPAPI(IppStatus, ippsFIRMR_32fc, ( const Ipp32fc* pSrc, Ipp32fc* pDst, int numIters, IppsFIRSpec_32fc* pSpec, const Ipp32fc *pDlySrc,  Ipp32fc *pDlyDst,  Ipp8u * pBuf))
IPPAPI(IppStatus, ippsFIRMR_64fc, ( const Ipp64fc* pSrc, Ipp64fc* pDst, int numIters, IppsFIRSpec_64fc* pSpec, const Ipp64fc *pDlySrc,  Ipp64fc *pDlyDst,  Ipp8u * pBuf))

IPPAPI(IppStatus, ippsFIRMR_16s, ( const Ipp16s* pSrc, Ipp16s* pDst, int numIters, IppsFIRSpec_32f* pSpec, const Ipp16s* pDlySrc,  Ipp16s* pDlyDst,  Ipp8u * pBuf))
IPPAPI(IppStatus, ippsFIRMR_16sc, ( const Ipp16sc* pSrc, Ipp16sc* pDst, int numIters, IppsFIRSpec_32fc* pSpec, const Ipp16sc* pDlySrc,  Ipp16sc* pDlyDst,  Ipp8u * pBuf))

#if defined (_IPP_STDCALL_CDECL)
  #undef  _IPP_STDCALL_CDECL
  #define __stdcall __cdecl
#endif


#ifdef __cplusplus
}
#endif

#endif /* __IPPS_H__ */
/* ////////////////////////// End of file "ipps.h" ////////////////////////// */
