ippch.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 ippch header file by PERL script at Fri Nov 11 17:45:13 2005

 #ifdef __cplusplus
 #if !defined( __IPPCH_HPP__ )
 #define   __IPPCH_HPP__
 #include "ippch.h"
 namespace IPPCH
 {
//-- #if !defined( __IPPCH_H__ ) || defined( _OWN_BLDPCS )
//-- #define __IPPCH_H__

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

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

//-- #if !defined( _OWN_BLDPCS )

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


//-- typedef struct {
//--  void *pFind;
//--  int lenFind;
//-- } IppRegExpFind;

//-- struct RegExpState;
//-- typedef struct RegExpState IppRegExpState;

//-- #endif /* _OWN_BLDPCS */


/* /////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//                   Functions declarations
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// */


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippchGetLibVersion
//  Purpose:    getting of the library version
//  Returns:    the structure of information about version
//              of ippCH library
//  Parameters:
//
//  Notes:      not necessary to release the returned structure
*/
//-- IPPAPI( const IppLibraryVersion*, ippchGetLibVersion, (void) )

/* /////////////////////////////////////////////////////////////////////////////
//                String Functions
///////////////////////////////////////////////////////////////////////////// */

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFind_8u        ippsFind_16u
//              ippsFindC_8u       ippsFindC_16u
//              ippsFindRev_8u     ippsFindRev_16u
//              ippsFindRevC_8u    ippsFindRevC_16u
//
//  Purpose:    Finds the match for string of elements or single element
//              within source string in direct or reverse direction
//
//  Arguments:
//     pSrc    - pointer to the source string
//     len     - source string lengh
//     pFind   - pointer to the searching string
//     lenFind - searching string length
//     valFind - searching element
//     pIndex  - pointer to the result index:
//               *pIndex = index of first occurrence ;
//               *pIndex = -1 if no match;
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc, pFind or pIndex are NULL
//   ippStsLengthErr   len or lenFind are negative
*/
 static inline IppStatus ippsFind( const Ipp8u* pSrc, int len, const Ipp8u* pFind, int
                             lenFind, int *pIndex) {
     return ippsFind_8u( pSrc, len, pFind, lenFind, pIndex );
     }
 static inline IppStatus ippsFind( const Ipp16u* pSrc, int len, const Ipp16u* pFind,
                             int lenFind, int *pIndex) {
     return ippsFind_16u( pSrc, len, pFind, lenFind, pIndex );
     }
 static inline IppStatus ippsFind( const Ipp8u* pSrc, int len, Ipp8u valFind, int
                             *pIndex) {
     return ippsFindC_8u( pSrc, len, valFind, pIndex );
     }
 static inline IppStatus ippsFind( const Ipp16u* pSrc, int len, Ipp16u valFind, int
                             *pIndex) {
     return ippsFindC_16u( pSrc, len, valFind, pIndex );
     }

 static inline IppStatus ippsFindRev( const Ipp8u* pSrc, int len, const Ipp8u* pFind,
                             int lenFind, int *pIndex) {
     return ippsFindRev_8u( pSrc, len, pFind, lenFind, pIndex );
     }
 static inline IppStatus ippsFindRev( const Ipp16u* pSrc, int len, const Ipp16u* pFind,
                             int lenFind, int *pIndex) {
     return ippsFindRev_16u( pSrc, len, pFind, lenFind, pIndex );
     }
 static inline IppStatus ippsFindRev( const Ipp8u* pSrc, int len, Ipp8u valFind, int
                             *pIndex) {
     return ippsFindRevC_8u( pSrc, len, valFind, pIndex );
     }
 static inline IppStatus ippsFindRev( const Ipp16u* pSrc, int len, Ipp16u valFind, int
                             *pIndex) {
     return ippsFindRevC_16u( pSrc, len, valFind, pIndex );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsCompare_8u        ippsCompare_16u
//
//  Purpose:    Compares two strings element-by-element
//
//  Arguments:
//     pSrc1   - pointer to the first string
//     pSrc2   - pointer to the second string
//     len     - string lengh to compare
//     pResult - pointer to the result:
//               *pResult =  0 if src1 == src2;
//               *pResult = >0 if src1 >  src2;
//               *pResult = <0 if src1 <  src2;
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc1, pSrc2 or pResult are NULL
//   ippStsLengthErr   len is negative
*/
 static inline IppStatus ippsCompare( const Ipp8u* pSrc1, const Ipp8u* pSrc2, int len,
                             int *pResult) {
     return ippsCompare_8u( pSrc1, pSrc2, len, pResult );
     }
 static inline IppStatus ippsCompare( const Ipp16u* pSrc1, const Ipp16u* pSrc2, int
                             len, int *pResult) {
     return ippsCompare_16u( pSrc1, pSrc2, len, pResult );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsEqual_8u        ippsEqual_16u
//
//  Purpose:    Compares two strings element-by-element
//
//  Arguments:
//     pSrc1   - pointer to the first string
//     pSrc2   - pointer to the second string
//     len     - string lengh to compare
//     pResult - pointer to the result:
//               *pResult =  1 if src1 == src2;
//               *pResult =  0 if src1 != src2;
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc1, pSrc2 or pResult are NULL
//   ippStsLengthErr   len is negative
*/
 static inline IppStatus ippsEqual( const Ipp8u* pSrc1, const Ipp8u* pSrc2, int len,
                             int *pResult) {
     return ippsEqual_8u( pSrc1, pSrc2, len, pResult );
     }
 static inline IppStatus ippsEqual( const Ipp16u* pSrc1, const Ipp16u* pSrc2, int len,
                             int *pResult) {
     return ippsEqual_16u( pSrc1, pSrc2, len, pResult );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsTrimC_8u_I        ippsTrimC_16u_I
//
//  Purpose:    Deletes an odd symbol at the end and the beginning of a string
//              in-place
//
//  Arguments:
//     pSrcDst - pointer to the string
//     pLen    - pointer to the string length:
//               *pLen = source length on input;
//               *pLen = destination length on output;
//     odd     - odd symbol
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrcDst or pLen are NULL
//   ippStsLengthErr   *pLen is negative
*/
 static inline IppStatus ippsTrim( Ipp8u* pSrcDst, int* pLen, Ipp8u odd) {
     return ippsTrimC_8u_I( pSrcDst, pLen, odd );
     }
 static inline IppStatus ippsTrim( Ipp16u* pSrcDst, int* pLen, Ipp16u odd) {
     return ippsTrimC_16u_I( pSrcDst, pLen, odd );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsTrimC_8u        ippsTrimC_16u
//
//  Purpose:    Deletes an odd symbol at the end and the beginning of a string
//
//  Arguments:
//     pSrc    - pointer to the source string
//     srcLen  - source string length
//     odd     - odd symbol
//     pDst    - pointer to the destination string
//     pDstLen - pointer to the destination string length:
//               *pDstLen doesn't use as input value;
//               *pDstLen = destination length on output;
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrcDst, pDst or pDstLen are NULL
//   ippStsLengthErr   srcLen is negative
*/
 static inline IppStatus ippsTrim( const Ipp8u* pSrc, int srcLen, Ipp8u odd, Ipp8u*
                             pDst, int* pDstLen) {
     return ippsTrimC_8u( pSrc, srcLen, odd, pDst, pDstLen );
     }
 static inline IppStatus ippsTrim( const Ipp16u* pSrc, int srcLen, Ipp16u odd, Ipp16u*
                             pDst, int* pDstLen) {
     return ippsTrimC_16u( pSrc, srcLen, odd, pDst, pDstLen );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:          ippsUppercase_16u_I
//                 ippsLowercase_16u_I
//                 ippsUppercase_16u
//                 ippsLowercase_16u
//
//  Purpose:    Forms an uppercase or lowercase version of the Unicode string
//
//  Arguments:
//     pSrc    - pointer to the source string
//     pDst    - pointer to the destination string
//     pSrcDst - pointer to the string for in-place operation
//     len     - string length
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc, pDst or pSrcDst are NULL;
//   ippStsLengthErr   len is negative;
*/

 static inline IppStatus ippsUppercase( Ipp16u* pSrcDst, int len) {
     return ippsUppercase_16u_I( pSrcDst, len );
     }
 static inline IppStatus ippsLowercase( Ipp16u* pSrcDst, int len) {
     return ippsLowercase_16u_I( pSrcDst, len );
     }
 static inline IppStatus ippsUppercase( const Ipp16u* pSrc, Ipp16u* pDst, int len) {
     return ippsUppercase_16u( pSrc, pDst, len );
     }
 static inline IppStatus ippsLowercase( const Ipp16u* pSrc, Ipp16u* pDst, int len) {
     return ippsLowercase_16u( pSrc, pDst, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsUppercaseLatin_8u_I   ippsUppercaseLatin_16u_I
//              ippsLowercaseLatin_8u_I   ippsLowercaseLatin_16u_I
//              ippsLowercaseLatin_8u     ippsUppercaseLatin_16u
//              ippsUppercaseLatin_8u     ippsLowercaseLatin_16u
//
//  Purpose:    Forms an uppercase or lowercase version of the ASCII string
//
//  Arguments:
//     pSrc    - pointer to the source string
//     pDst    - pointer to the destination string
//     pSrcDst - pointer to the string for in-place operation
//     len     - string length
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc, pDst or pSrcDst are NULL;
//   ippStsLengthErr   len is negative;
*/
 static inline IppStatus ippsUppercaseLatin( Ipp8u* pSrcDst, int len) {
     return ippsUppercaseLatin_8u_I( pSrcDst, len );
     }
 static inline IppStatus ippsLowercaseLatin( Ipp8u* pSrcDst, int len) {
     return ippsLowercaseLatin_8u_I( pSrcDst, len );
     }
 static inline IppStatus ippsUppercaseLatin( Ipp16u* pSrcDst, int len) {
     return ippsUppercaseLatin_16u_I( pSrcDst, len );
     }
 static inline IppStatus ippsLowercaseLatin( Ipp16u* pSrcDst, int len) {
     return ippsLowercaseLatin_16u_I( pSrcDst, len );
     }
 static inline IppStatus ippsLowercaseLatin( const Ipp8u* pSrc, Ipp8u* pDst, int len) {
     return ippsLowercaseLatin_8u( pSrc, pDst, len );
     }