ipps.hpp

经典的嵌入式教程C和C++的内容中的源代码

/*
//
//                  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) 2003-2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives Using Intel(R) IPP in
//     C++ Applications Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel(R) Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ipplic.htm located in the root directory of your Intel(R) IPP
//  product installation for more information.
//
*/
// Generated from ipps header file by PERL script at Mon Dec 26 19:27:45 2005

 #ifdef __cplusplus
 #if !defined( __IPPS_HPP__ )
 #define   __IPPS_HPP__
 #include "ipps.h"
 namespace IPPSP
 {

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

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

//-- #ifdef __cplusplus
//-- extern "C" {
//-- #endif

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


//-- #if !defined( _OWN_BLDPCS )
//-- typedef struct {
//--     int left;
//--     int right;
//-- } IppsROI;
//-- #endif /* _OWN_BLDPCS */


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsGetLibVersion
//  Purpose:    get the library version
//  Parameters:
//  Returns:    pointer to structure describing version of the ipps library
//
//  Notes:      don't free the pointer
*/
//-- IPPAPI( const IppLibraryVersion*, ippsGetLibVersion, (void) )

/* /////////////////////////////////////////////////////////////////////////////
//                   Functions to allocate and free memory
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsMalloc
//  Purpose:    32-byte aligned memory allocation
//  Parameter:
//    len       number of elements (according to their type)
//  Returns:    pointer to allocated memory
//
//  Notes:      the memory allocated by ippsMalloc has to be free by ippsFree
//              function only.
*/

//-- IPPAPI( Ipp8u*,   ippsMalloc_8u,  (int len) )
//-- IPPAPI( Ipp16u*,  ippsMalloc_16u, (int len) )
//-- IPPAPI( Ipp32u*,  ippsMalloc_32u, (int len) )
//-- IPPAPI( Ipp8s*,   ippsMalloc_8s,  (int len) )
//-- IPPAPI( Ipp16s*,  ippsMalloc_16s, (int len) )
//-- IPPAPI( Ipp32s*,  ippsMalloc_32s, (int len) )
//-- IPPAPI( Ipp64s*,  ippsMalloc_64s, (int len) )

//-- IPPAPI( Ipp32f*,  ippsMalloc_32f, (int len) )
//-- IPPAPI( Ipp64f*,  ippsMalloc_64f, (int len) )

//-- IPPAPI( Ipp8sc*,  ippsMalloc_8sc,  (int len) )
//-- IPPAPI( Ipp16sc*, ippsMalloc_16sc, (int len) )
//-- IPPAPI( Ipp32sc*, ippsMalloc_32sc, (int len) )
//-- IPPAPI( Ipp64sc*, ippsMalloc_64sc, (int len) )
//-- IPPAPI( Ipp32fc*, ippsMalloc_32fc, (int len) )
//-- IPPAPI( Ipp64fc*, ippsMalloc_64fc, (int len) )


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFree
//  Purpose:    free memory allocated by the ippsMalloc functions
//  Parameter:
//    ptr       pointer to the memory allocated by the ippsMalloc functions
//
//  Notes:      use the function to free memory allocated by ippsMalloc_*
*/
//-- IPPAPI( void, ippsFree, (void* ptr) )



/* /////////////////////////////////////////////////////////////////////////////
//                   Vector Initialization functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCopy
//  Purpose:    copy data from source to destination vector
//  Parameters:
//    pSrc        pointer to the input vector
//    pDst        pointer to the output vector
//    len         length of the vectors, number of items
//  Return:
//    ippStsNullPtrErr        pointer(s) to the data is NULL
//    ippStsSizeErr           length of the vectors is less or equal zero
//    ippStsNoErr             otherwise
*/

 inline IppStatus ippsCopy( const Ipp8u* pSrc, Ipp8u* pDst, int len) {
     return ippsCopy_8u( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp16s* pSrc, Ipp16s* pDst, int len) {
     return ippsCopy_16s( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp16sc* pSrc, Ipp16sc* pDst, int len) {
     return ippsCopy_16sc( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp32f* pSrc, Ipp32f* pDst, int len) {
     return ippsCopy_32f( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp32fc* pSrc, Ipp32fc* pDst, int len) {
     return ippsCopy_32fc( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp64f* pSrc, Ipp64f* pDst, int len) {
     return ippsCopy_64f( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp64fc* pSrc, Ipp64fc* pDst, int len) {
     return ippsCopy_64fc( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp32s* pSrc, Ipp32s* pDst, int len) {
     return ippsCopy_32s( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp32sc* pSrc, Ipp32sc* pDst, int len) {
     return ippsCopy_32sc( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp64s* pSrc, Ipp64s* pDst, int len) {
     return ippsCopy_64s( pSrc, pDst, len );
     }
 inline IppStatus ippsCopy( const Ipp64sc* pSrc, Ipp64sc* pDst, int len) {
     return ippsCopy_64sc( pSrc, pDst, len );
     }


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCopy_1u
//  Purpose:    copy bit's data from source to destination vector
//  Parameters:
//    pSrc          pointer to the input vector
//    srcBitOffset  offset in the first byte of the source vector
//    pDst          pointer to the output vector
//    dstBitOffset  offset in the first byte of the destination vector
//    len           length of the vectors, number of bits
//  Return:
//    ippStsNullPtrErr        pointer(s) to the data is NULL
//    ippStsSizeErr           length of the vectors is less or equal zero
//    ippStsNoErr             otherwise
*/

 inline IppStatus ippsCopy( const Ipp8u* pSrc, int srcBitOffset, Ipp8u* pDst, int
                             dstBitOffset, int len) {
     return ippsCopy_1u( pSrc, srcBitOffset, pDst, dstBitOffset, 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
*/

 inline IppStatus ippsMove( const Ipp8u* pSrc, Ipp8u* pDst, int len) {
     return ippsMove_8u( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp16s* pSrc, Ipp16s* pDst, int len) {
     return ippsMove_16s( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp16sc* pSrc, Ipp16sc* pDst, int len) {
     return ippsMove_16sc( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp32f* pSrc, Ipp32f* pDst, int len) {
     return ippsMove_32f( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp32fc* pSrc, Ipp32fc* pDst, int len) {
     return ippsMove_32fc( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp64f* pSrc, Ipp64f* pDst, int len) {
     return ippsMove_64f( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp64fc* pSrc, Ipp64fc* pDst, int len) {
     return ippsMove_64fc( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp32s* pSrc, Ipp32s* pDst, int len) {
     return ippsMove_32s( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp32sc* pSrc, Ipp32sc* pDst, int len) {
     return ippsMove_32sc( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp64s* pSrc, Ipp64s* pDst, int len) {
     return ippsMove_64s( pSrc, pDst, len );
     }
 inline IppStatus ippsMove( const Ipp64sc* pSrc, Ipp64sc* pDst, int len) {
     return ippsMove_64sc( pSrc, pDst, 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
*/

 inline IppStatus ippsZero( Ipp8u* pDst, int len) {
     return ippsZero_8u( pDst, len );
     }
 inline IppStatus ippsZero( Ipp16s* pDst, int len) {
     return ippsZero_16s( pDst, len );
     }
 inline IppStatus ippsZero( Ipp16sc* pDst, int len) {
     return ippsZero_16sc( pDst, len );
     }
 inline IppStatus ippsZero( Ipp32f* pDst, int len) {
     return ippsZero_32f( pDst, len );
     }
 inline IppStatus ippsZero( Ipp32fc* pDst, int len) {
     return ippsZero_32fc( pDst, len );
     }
 inline IppStatus ippsZero( Ipp64f* pDst, int len) {
     return ippsZero_64f( pDst, len );
     }
 inline IppStatus ippsZero( Ipp64fc* pDst, int len) {
     return ippsZero_64fc( pDst, len );
     }
 inline IppStatus ippsZero( Ipp32s* pDst, int len) {
     return ippsZero_32s( pDst, len );
     }
 inline IppStatus ippsZero( Ipp32sc* pDst, int len) {
     return ippsZero_32sc( pDst, len );
     }
 inline IppStatus ippsZero( Ipp64s* pDst, int len) {
     return ippsZero_64s( pDst, len );
     }
 inline IppStatus ippsZero( Ipp64sc* pDst, int len) {
     return ippsZero_64sc( pDst, 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
*/

 inline IppStatus ippsSet( Ipp8u val, Ipp8u* pDst, int len) {
     return ippsSet_8u( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp16s val, Ipp16s* pDst, int len) {
     return ippsSet_16s( val, pDst, len );
     }
 inline IppStatus ippsSet( Ipp16sc val, Ipp16sc* pDst, int len) {
     return ippsSet_16sc( val, pDst, len );
     }