ippch.hpp

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

 static inline IppStatus ippsUppercaseLatin( const Ipp8u* pSrc, Ipp8u* pDst, int len) {
     return ippsUppercaseLatin_8u( pSrc, pDst, len );
     }
 static inline IppStatus ippsUppercaseLatin( const Ipp16u* pSrc, Ipp16u* pDst, int len)
                             {
     return ippsUppercaseLatin_16u( pSrc, pDst, len );
     }
 static inline IppStatus ippsLowercaseLatin( const Ipp16u* pSrc, Ipp16u* pDst, int len)
                             {
     return ippsLowercaseLatin_16u( pSrc, pDst, len );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsHash_8u32u        ippsHash_16u32u
//
//  Purpose:    Calculates hashed value so that different strings yield different
//              values:
//              for (i=0; i<len; i++) hash = (hash << 1) ^ src[i];
//
//  Arguments:
//     pSrc     - pointer to the source string
//     len      - source string length
//     pHashVal - pointer to the result value
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc or pHashVal are NULL
//   ippStsLengthErr   len is negative
*/

 static inline IppStatus ippsHash( const Ipp8u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHash_8u32u( pSrc, len, pHashVal );
     }
 static inline IppStatus ippsHash( const Ipp16u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHash_16u32u( pSrc, len, pHashVal );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsHashSJ2_8u32u         ippsHashSJ2_16u32u
//
//  Purpose:    Calculates hashed value so that different strings yield different
//              values:
//              for (i=0; i<len; i++) hash =
//
//  Arguments:
//     pSrc     - pointer to the source string
//     len      - source string length
//     pHashVal - pointer to the result value
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc or pHashVal are NULL
//   ippStsLengthErr   len is negative
*/

 static inline IppStatus ippsHashSJ2( const Ipp8u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHashSJ2_8u32u( pSrc, len, pHashVal );
     }
 static inline IppStatus ippsHashSJ2( const Ipp16u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHashSJ2_16u32u( pSrc, len, pHashVal );
     }
/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsHashMSCS_8u32u        ippsHashMSCS_16u32u
//
//  Purpose:    Calculates hashed value so that different strings yield different
//              values:
//              for (i=0; i<len; i++) hash =
//
//  Arguments:
//     pSrc     - pointer to the source string
//     len      - source string length
//     pHashVal - pointer to the result value
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc or pHashVal are NULL
//   ippStsLengthErr   len is negative
*/

 static inline IppStatus ippsHashMSCS( const Ipp8u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHashMSCS_8u32u( pSrc, len, pHashVal );
     }
 static inline IppStatus ippsHashMSCS( const Ipp16u* pSrc, int len, Ipp32u* pHashVal) {
     return ippsHashMSCS_16u32u( pSrc, len, pHashVal );
     }




/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConcat_8u   ippsConcat_16u
//
//  Purpose:    Concatenates two strings together
//
//  Arguments:
//     pSrc1   - pointer to the first source string
//     len1    - first source string lengh
//     pSrc2   - pointer to the second source string
//     len2    - second source string lengh
//     pDst    - pointer to the destination string
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc1, pSrc2 or pDst are NULL
//   ippStsLengthErr   len1 or len2 are negative
*/
 static inline IppStatus ippsConcat( const Ipp8u* pSrc1, int len1, const Ipp8u* pSrc2,
                             int len2, Ipp8u* pDst) {
     return ippsConcat_8u( pSrc1, len1, pSrc2, len2, pDst );
     }
 static inline IppStatus ippsConcat( const Ipp16u* pSrc1, int len1, const Ipp16u*
                             pSrc2, int len2, Ipp16u* pDst) {
     return ippsConcat_16u( pSrc1, len1, pSrc2, len2, pDst );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConcat_8u_D2L   ippsConcat_16u_D2L
//
//  Purpose:    Concatenates several strings together
//
//  Arguments:
//     pSrc    - pointer to the array of source strings
//     srcLen  - pointer to the array of source strings' lenghs
//     numSrc  - number of source strings
//     pDst    - pointer to the destination string
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc, srcLen or pDst are NULL;
//                     pSrc[i] is NULL for i < numSrc
//   ippStsLengthErr   srcLen[i] is negative for i < numSrc
//   ippStsSizeErr     numSrc is not positive
*/
 static inline IppStatus ippsConcat( const Ipp8u* const pSrc[], const int srcLen[], int
                             numSrc, Ipp8u* pDst) {
     return ippsConcat_8u_D2L( pSrc, srcLen, numSrc, pDst );
     }
 static inline IppStatus ippsConcat( const Ipp16u* const pSrc[], const int srcLen[],
                             int numSrc, Ipp16u* pDst) {
     return ippsConcat_16u_D2L( pSrc, srcLen, numSrc, pDst );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsConcatC_8u_D2L   ippsConcatC_16u_D2L
//
//  Purpose:    Concatenates several strings together and separates them
//              by the symbol delimiter
//
//  Arguments:
//     pSrc    - pointer to the array of source strings
//     srcLen  - pointer to the array of source strings' lenghs
//     numSrc  - number of source strings
//     delim   - delimiter
//     pDst    - pointer to the destination string
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  pSrc, srcLen or pDst are NULL;
//                     pSrc[i] is NULL for i < numSrc
//   ippStsLengthErr   srcLen[i] is negative for i < numSrc
//   ippStsSizeErr     numSrc is not positive
*/
 static inline IppStatus ippsConcat( const Ipp8u* const pSrc[], const int srcLen[], int
                             numSrc, Ipp8u delim, Ipp8u* pDst) {
     return ippsConcatC_8u_D2L( pSrc, srcLen, numSrc, delim, pDst );
     }
 static inline IppStatus ippsConcat( const Ipp16u* const pSrc[], const int srcLen[],
                             int numSrc, Ipp16u delim, Ipp16u* pDst) {
     return ippsConcatC_16u_D2L( pSrc, srcLen, numSrc, delim, pDst );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsSplitC_8u_D2L   ippsSplitC_16u_D2L
//
//  Purpose:    Splits source string to several destination strings
//              using the symbol delimiter; all delimiters are significant,
//              in the case of double delimiter empty string is inserted.
//
//  Arguments:
//     pSrc    - pointer to the source string
//     srcLen  - source string length
//     delim   - delimiter
//     pDst    - pointer to the array of destination strings
//     dstLen  - pointer to the array of destination strings' lenghs
//     pNumDst - pointer to the number of destination strings:
//               *pNumDst = initial number of destination strings on input;
//               *pNumDst = number of splitted strings on output;
//
//  Return:
//     ippStsNoErr       Ok
//  ERRORS:
//     ippStsNullPtrErr  pSrc, pDst, dstLen or pNumDst are NULL;
//                       pDst[i] is NULL for i < number of splitted strings
//     ippStsLengthErr   srcLen is negative;
//                       dstLen[i] is negative for i < number of splitted strings
//     ippStsSizeErr     *pNumDst is not positive
//  WARNINGS:
//     ippStsOvermuchStrings  the initial number of destination strings is less
//                            than the number of splitted strings;
//                            number of destination strings is truncated to
//                            initial number in this case
//     ippStsOverlongString   the length of one of destination strings is less than
//                            length of corresponding splitted string;
//                            splitted string is truncated to destination length
//                            in this case
*/
 static inline IppStatus ippsSplit( const Ipp8u* pSrc, int srcLen, Ipp8u delim, Ipp8u*
                             pDst[], int dstLen[], int* pNumDst) {
     return ippsSplitC_8u_D2L( pSrc, srcLen, delim, pDst, dstLen, pNumDst );
     }
 static inline IppStatus ippsSplit( const Ipp16u* pSrc, int srcLen, Ipp16u delim,
                             Ipp16u* pDst[], int dstLen[], int* pNumDst) {
     return ippsSplitC_16u_D2L( pSrc, srcLen, delim, pDst, dstLen, pNumDst );
     }


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsFindCAny_8u
//              ippsFindCAny_16u
//              ippsFindRevCAny_8u
//              ippsFindRevCAny_16u
//
//  Purpose:    Reports the index of the first/last occurrence in
//              the vector of any value in a specified array.
//
//  Arguments:
//     pSrc    - The pointer of vector to find.
//     len     - The length of the vector.
//     pAnyOf  - A pointer of array containing one or more values to seek.
//     lenFind - The length of array.
//     pIndex  - The positive integer index of the first occurrence in
//               the vector where any value in pAnyOf was found;
//               otherwise, -1 if no value in pAnyOf was found.
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  Any of pointers is NULL.
//   ippStsLengthErr   len or lenAnyOf are negative.
*/
 static inline IppStatus ippsFindCAny( const Ipp8u* pSrc, int len, const Ipp8u* pAnyOf,
                             int lenAnyOf, int* pIndex) {
     return ippsFindCAny_8u( pSrc, len, pAnyOf, lenAnyOf, pIndex );
     }
 static inline IppStatus ippsFindCAny( const Ipp16u* pSrc, int len, const Ipp16u*
                             pAnyOf, int lenAnyOf, int* pIndex) {
     return ippsFindCAny_16u( pSrc, len, pAnyOf, lenAnyOf, pIndex );
     }
 static inline IppStatus ippsFindRevCAny( const Ipp8u* pSrc, int len, const Ipp8u*
                             pAnyOf, int lenAnyOf, int* pIndex) {
     return ippsFindRevCAny_8u( pSrc, len, pAnyOf, lenAnyOf, pIndex );
     }
 static inline IppStatus ippsFindRevCAny( const Ipp16u* pSrc, int len, const Ipp16u*
                             pAnyOf, int lenAnyOf, int* pIndex) {
     return ippsFindRevCAny_16u( pSrc, len, pAnyOf, lenAnyOf, pIndex );
     }


/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsReplaceC_8u
//              ippsReplaceC_16u
//
//  Purpose:    Replaces all occurrences of a specified value in
//              the vector with another specified value.
//
//  Arguments:
//     pSrc    - The pointer of vector to replace.
//     pDst    - The ponter of replaced vector.
//     len     - The length of the vector.
//     oldVal  - A value to be replaced.
//     newVal  - A value to replace all occurrences of oldVal.
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  Any of pointers is NULL.
//   ippStsLengthErr   len is negative.
*/
 static inline IppStatus ippsReplace( const Ipp8u* pSrc, Ipp8u* pDst, int len, Ipp8u
                             oldVal, Ipp8u newVal) {
     return ippsReplaceC_8u( pSrc, pDst, len, oldVal, newVal );
     }
 static inline IppStatus ippsReplace( const Ipp16u* pSrc, Ipp16u* pDst, int len, Ipp16u
                             oldVal, Ipp16u newVal) {
     return ippsReplaceC_16u( pSrc, pDst, len, oldVal, newVal );
     }

/* /////////////////////////////////////////////////////////////////////////////
//  Name:       ippsTrimCAny_8u
//              ippsTrimCAny_16u
//              ippsTrimEndCAny_8u
//              ippsTrimEndCAny_16u
//              ippsTrimStartCAny_8u
//              ippsTrimStartCAny_16u
//
//  Purpose:    Removes all occurrences of a set of specified values
//              from:
//                TrimCAny  - the beginning and end of the vector.
//                TrimEndCAny   - the end of the vector.
//                TrimStartCAny - the beginning of the vector.
//
//  Arguments:
//     pSrc    - The pointer of src vector to remove.
//     srcLen  - The length of the src vector.
//     pTrim   - An array of values to be removed.
//     trimLen - The length of the array values.
//     pDst    - The pointer of dst vector to result save.
//     pDstLen - The result length of the dst vector.
//
//  Return:
//   ippStsNoErr       Ok
//   ippStsNullPtrErr  Any of pointers is NULL.
//   ippStsLengthErr   srcLen or trimLen are negative.
//
//  Note: