/* /////////////////////////////////////////////////////////////////////////////
//
// 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) 2002-2009 Intel Corporation. All Rights Reserved.
//
//
// Intel(R) Integrated Performance Primitives
// String Manipulations Library (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;
typedef enum {
ippFmtASCII = 0,
ippFmtUTF8
} IppRegExpFormat;
#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 length
// 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
*/
IPPAPI (IppStatus, ippsFind_8u, (const Ipp8u* pSrc, int len,
const Ipp8u* pFind, int lenFind,
int *pIndex))
IPPAPI (IppStatus, ippsFind_16u, (const Ipp16u* pSrc, int len,
const Ipp16u* pFind, int lenFind,
int *pIndex))
IPPAPI (IppStatus, ippsFindC_8u, (const Ipp8u* pSrc, int len,
Ipp8u valFind, int *pIndex))
IPPAPI (IppStatus, ippsFindC_16u, (const Ipp16u* pSrc, int len,
Ipp16u valFind, int *pIndex))
IPPAPI (IppStatus, ippsFindRev_8u, (const Ipp8u* pSrc, int len,
const Ipp8u* pFind, int lenFind,
int *pIndex))
IPPAPI (IppStatus, ippsFindRev_16u, (const Ipp16u* pSrc, int len,
const Ipp16u* pFind, int lenFind,
int *pIndex))
IPPAPI (IppStatus, ippsFindRevC_8u, (const Ipp8u* pSrc, int len,
Ipp8u valFind, int *pIndex))
IPPAPI (IppStatus, ippsFindRevC_16u, (const Ipp16u* pSrc, int len,
Ipp16u valFind, int *pIndex))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsFind_Z_8u ippsFind_Z_16u
// ippsFindC_Z_8u ippsFindC_Z_16u
//
// Purpose: Finds the match for zero-ended string of elements or single element
// within source zero-ended string in direct or reverse direction
//
// Arguments:
// pSrcZ - pointer to the source zero-ended string
// pFindZ - pointer to the searching zero-ended string
// valFind - searching element
// pIndex - pointer to the result index:
// *pIndex = index of first occurrence;
// *pIndex = -1 if no match;
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pSrcZ, pFindZ or pIndex are NULL
*/
IPPAPI (IppStatus, ippsFind_Z_8u, (const Ipp8u* pSrcZ,
const Ipp8u* pFindZ, int *pIndex))
IPPAPI (IppStatus, ippsFind_Z_16u, (const Ipp16u* pSrcZ,
const Ipp16u* pFindZ, int *pIndex))
IPPAPI (IppStatus, ippsFindC_Z_8u, (const Ipp8u* pSrcZ,
Ipp8u valFind, int *pIndex))
IPPAPI (IppStatus, ippsFindC_Z_16u, (const Ipp16u* pSrcZ,
Ipp16u valFind, int *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 length 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
*/
IPPAPI (IppStatus, ippsCompare_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
int len, int *pResult))
IPPAPI (IppStatus, ippsCompare_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
int len, int *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 length 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
*/
IPPAPI (IppStatus, ippsEqual_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
int len, int *pResult))
IPPAPI (IppStatus, ippsEqual_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
int len, int *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
*/
IPPAPI (IppStatus, ippsTrimC_8u_I, (Ipp8u* pSrcDst, int* pLen, Ipp8u odd ))
IPPAPI (IppStatus, ippsTrimC_16u_I, (Ipp16u* pSrcDst, int* pLen, Ipp16u 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
*/
IPPAPI (IppStatus, ippsTrimC_8u, (const Ipp8u* pSrc, int srcLen, Ipp8u odd,
Ipp8u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimC_16u, (const Ipp16u* pSrc, int srcLen, Ipp16u odd,
Ipp16u* pDst, int* 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;
*/
IPPAPI (IppStatus, ippsUppercase_16u_I,( Ipp16u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsLowercase_16u_I,( Ipp16u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsUppercase_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
IPPAPI (IppStatus, ippsLowercase_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int 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;
*/
IPPAPI (IppStatus, ippsUppercaseLatin_8u_I, ( Ipp8u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsLowercaseLatin_8u_I, ( Ipp8u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsUppercaseLatin_16u_I,( Ipp16u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsLowercaseLatin_16u_I,( Ipp16u* pSrcDst, int len ))
IPPAPI (IppStatus, ippsLowercaseLatin_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
IPPAPI (IppStatus, ippsUppercaseLatin_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
IPPAPI (IppStatus, ippsUppercaseLatin_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
IPPAPI (IppStatus, ippsLowercaseLatin_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int 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
*/
IPPAPI (IppStatus, ippsHash_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal ))
IPPAPI (IppStatus, ippsHash_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* 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
*/
IPPAPI (IppStatus,ippsHashSJ2_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal))
IPPAPI (IppStatus,ippsHashSJ2_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* 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
*/
IPPAPI (IppStatus,ippsHashMSCS_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal))
IPPAPI (IppStatus,ippsHashMSCS_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* pHashVal))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConcat_8u ippsConcat_16u
//
// Purpose: Concatenates two strings together
//
// Arguments:
// pSrc1 - pointer to the first source string
// len1 - first source string length
// pSrc2 - pointer to the second source string
// len2 - second source string length
// pDst - pointer to the destination string
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pSrc1, pSrc2 or pDst are NULL
// ippStsLengthErr len1 or len2 are negative
*/
IPPAPI (IppStatus, ippsConcat_8u, (const Ipp8u* pSrc1, int len1,
const Ipp8u* pSrc2, int len2,
Ipp8u* pDst))
IPPAPI (IppStatus, ippsConcat_16u, (const Ipp16u* pSrc1, int len1,
const Ipp16u* pSrc2, int len2,
Ipp16u* 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' lengths
// 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
*/
IPPAPI (IppStatus, ippsConcat_8u_D2L, (const Ipp8u* const pSrc[], const int srcLen[], int numSrc,
Ipp8u* pDst ))
IPPAPI (IppStatus, ippsConcat_16u_D2L, (const Ipp16u* const pSrc[], const int srcLen[], int numSrc,
Ipp16u* 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' lengths
// 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
*/
IPPAPI (IppStatus, ippsConcatC_8u_D2L, (const Ipp8u* const pSrc[], const int srcLen[], int numSrc,
Ipp8u delim, Ipp8u* pDst ))
IPPAPI (IppStatus, ippsConcatC_16u_D2L, (const Ipp16u* const pSrc[], const int srcLen[], int numSrc,
Ipp16u delim, Ipp16u* 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' lengths
// 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
*/
IPPAPI (IppStatus, ippsSplitC_8u_D2L, (const Ipp8u* pSrc, int srcLen, Ipp8u delim,
Ipp8u* pDst[], int dstLen[], int* pNumDst))
IPPAPI (IppStatus, ippsSplitC_16u_D2L, (const Ipp16u* pSrc, int srcLen, Ipp16u delim,
Ipp16u* pDst[], int dstLen[], int* 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.
*/
IPPAPI (IppStatus, ippsFindCAny_8u, ( const Ipp8u* pSrc, int len,
const Ipp8u* pAnyOf, int lenAnyOf, int* pIndex ))
IPPAPI (IppStatus, ippsFindCAny_16u, ( const Ipp16u* pSrc, int len,
const Ipp16u* pAnyOf, int lenAnyOf, int* pIndex ))
IPPAPI (IppStatus, ippsFindRevCAny_8u, ( const Ipp8u* pSrc, int len,
const Ipp8u* pAnyOf, int lenAnyOf, int* pIndex ))
IPPAPI (IppStatus, ippsFindRevCAny_16u, ( const Ipp16u* pSrc, int len,
const Ipp16u* pAnyOf, int lenAnyOf, int* 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.
*/
IPPAPI (IppStatus, ippsReplaceC_8u, ( const Ipp8u* pSrc, Ipp8u* pDst, int len,
Ipp8u oldVal, Ipp8u newVal ))
IPPAPI (IppStatus, ippsReplaceC_16u, ( const Ipp16u* pSrc, Ipp16u* pDst, int len,
Ipp16u oldVal, Ipp16u 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:
// The length of the pDst should be sufficient;
// if values not found, *pDstLen = srcLen.
*/
IPPAPI (IppStatus, ippsTrimCAny_8u, ( const Ipp8u* pSrc, int srcLen,
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimCAny_16u, ( const Ipp16u* pSrc, int srcLen,
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimEndCAny_8u, ( const Ipp8u* pSrc, int srcLen,
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimEndCAny_16u, ( const Ipp16u* pSrc, int srcLen,
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimStartCAny_8u, ( const Ipp8u* pSrc, int srcLen,
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
IPPAPI (IppStatus, ippsTrimStartCAny_16u, ( const Ipp16u* pSrc, int srcLen,
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCompareIgnoreCase_16u
//
// Purpose: Compares two Unicode strings element-by-element
//
// Arguments:
// pSrc1 - pointer to the first string
// pSrc2 - pointer to the second string
// len - string length 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 is NULL
// ippStsLengthErr len is negative
*/
IPPAPI (IppStatus, ippsCompareIgnoreCase_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, int len,
int *pResult))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsCompareIgnoreCaseLatin_8u
// ippsCompareIgnoreCaseLatin_16u
//
// Purpose: Compares two ASCII strings element-by-element
//
// Arguments:
// pSrc1 - pointer to the first string
// pSrc2 - pointer to the second string
// len - string length 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 is NULL
// ippStsLengthErr len is negative
*/
IPPAPI (IppStatus, ippsCompareIgnoreCaseLatin_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2, int len,
int *pResult))
IPPAPI (IppStatus, ippsCompareIgnoreCaseLatin_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
int len, int *pResult))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsInsert_8u_I ippsInsert_16u_I
// ippsInsert_8u ippsInsert_16u
//
// Purpose: Inserts one string at a specified index position in other string
//
// Arguments:
// pSrc - pointer to the source string
// srcLen - source string length
// pInsert - pointer to the string to be inserted
// insertLen - length of the string to be inserted
// pDst - pointer to the destination string
// pSrcDst - pointer to the string for in-place operation
// pSrcDstLen - pointer to the string length:
// *pSrcDstLen = source length on input;
// *pSrcDstLen = destination length on output;
// startIndex - index of start position
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pSrc, pInsert, pDst, pSrcDst or pSrcDstLen is NULL
// ippStsLengthErr srcLen, insertLen, *pSrcDstLen or startIndex is negative Or
// startIndex is greater than srcLen or *pSrcDstLen
*/
IPPAPI (IppStatus, ippsInsert_8u_I, (const Ipp8u* pInsert, int insertLen, Ipp8u* pSrcDst,
int* pSrcDstLen, int startIndex))
IPPAPI (IppStatus, ippsInsert_16u_I, (const Ipp16u* pInsert, int insertLen, Ipp16u* pSrcDst,
int* pSrcDstLen, int startIndex))
IPPAPI (IppStatus, ippsInsert_8u, (const Ipp8u* pSrc, int srcLen, const Ipp8u* pInsert,
int insertLen, Ipp8u* pDst, int startIndex))
IPPAPI (IppStatus, ippsInsert_16u, (const Ipp16u* pSrc, int srcLen, const Ipp16u* pInsert,
int insertLen, Ipp16u* pDst, int startIndex))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRemove_8u_I ippsRemove_16u_I
// ippsRemove_8u ippsRemove_16u
//
// Purpose: Deletes a specified number of characters from the string
// beginning at a specified position.
//
// Arguments:
// pSrc - pointer to the source string
// srcLen - source string length
// pDst - pointer to the destination string
// pSrcDst - pointer to the string for in-place operation
// pSrcDstLen - pointer to the string length:
// *pSrcDstLen = source length on input;
// *pSrcDstLen = destination length on output;
// startIndex - index of start position
// len - number of characters to be deleted
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr pSrc, pDst, pSrcDst or pSrcDstLen are NULL
// ippStsLengthErr srcLen, *pSrcDstLen, len or startIndex is negative Or
// (startIndex + len) is greater than srcLen or *pSrcDstLen
*/
IPPAPI (IppStatus, ippsRemove_8u_I, (Ipp8u* pSrcDst, int* pSrcDstLen, int startIndex, int len))
IPPAPI (IppStatus, ippsRemove_16u_I, (Ipp16u* pSrcDst, int* pSrcDstLen, int startIndex, int len))
IPPAPI (IppStatus, ippsRemove_8u, (const Ipp8u* pSrc, int srcLen, Ipp8u* pDst, int startIndex,
int len))
IPPAPI (IppStatus, ippsRemove_16u, (const Ipp16u* pSrc, int srcLen, Ipp16u* pDst, int startIndex,
int len))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpInitAlloc
// Purpose: Allocates necessary memory, compiles a pattern into the
// internal form consideration corresponding options and
// writes it into the pRegExpState
//
// Parameters:
// pPattern Pointer to the pattern of regular expression
// pOptions Pointer to options for compiling and executing
// regular expression (possible values 'i','s','m','x','g')
// It should be NULL if no options are required.
// pRegExpState Pointer to the structure containing internal form of
// a regular expression.
// pErrOffset Pointer to offset into the pattern if compiling is break
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsMemAllocErr Can't allocate memory for pRegExpState
// ippStsRegExpOptionsErr Options are incorrect
// ippStsRegExpQuantifierErr Error caused by using wrong quantifier
// ippStsRegExpGroupingErr Error caused by using wrong grouping
// ippStsRegExpBackRefErr Error caused by using wrong back reference
// ippStsRegExpChClassErr Error caused by using wrong character class
// ippStsRegExpMetaChErr Error caused by using wrong metacharacter
//
*/
IPPAPI(IppStatus, ippsRegExpInitAlloc, ( const char* pPattern, const char* pOptions,
IppRegExpState** ppRegExpState, int* pErrOffset ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpGetSize
// Purpose: Computes the size of necessary memory (in bytes) for
// structure containing internal form of regular expression
//
// Parameters:
// pPattern Pointer to the pattern of regular expression
// pRegExpStateSize Pointer to the computed size of structure containing
// internal form of regular expression
//
// Return:
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpGetSize, ( const char* pPattern, int* pRegExpStateSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpInit
// Purpose: Compiles a pattern into the internal form consideration
// corresponding options and writes it into the pRegExpState
//
// Parameters:
// pPattern Pointer to the pattern of regular expression
// pOptions Pointer to options for compiling and executing
// regular expression (possible values 'i','s','m','x','g')
// It should be NULL if no options are required.
// pRegExpState Pointer to the structure containing internal form of
// a regular expression.
// pErrOffset Pointer to offset into the pattern if compiling is break
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsRegExpOptionsErr Options are incorrect
// ippStsRegExpQuantifierErr Error caused by using wrong quantifier
// ippStsRegExpGroupingErr Error caused by using wrong grouping
// ippStsRegExpBackRefErr Error caused by using wrong back reference
// ippStsRegExpChClassErr Error caused by using wrong character class
// ippStsRegExpMetaChErr Error caused by using wrong metacharacter
//
*/
IPPAPI(IppStatus, ippsRegExpInit, ( const char* pPattern, const char* pOptions,
IppRegExpState* pRegExpState, int* pErrOffset ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpSetMatchLimit
// Purpose: Changes initial value of the matches kept in stack
//
// Parameters:
// matchLimit New value of the matches kept in stack
// pRegExpState Pointer to the structure containing internal form of
// a regular expression
//
// Return:
// ippStsNullPtrErr Pointer is NULL
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpSetMatchLimit, ( int matchLimit, IppRegExpState* pRegExpState ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpSetFormat
// Purpose: Changes initial value of the matches kept in stack
//
// Parameters:
// fmt New source encoding mode
// pRegExpState Pointer to the structure containing internal form of
// a regular expression
//
// Return:
// ippStsNullPtrErr Pointer is NULL.
// ippStsRangeErr When
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpSetFormat, ( IppRegExpFormat fmt, IppRegExpState* pRegExpState ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpFree
// Purpose: Frees allocated memory for the structure containing
// internal form of regular expression
//
// Parameters:
// pRegExpState Pointer to the structure containing internal form of
// a regular expression.
//
*/
IPPAPI(void, ippsRegExpFree, ( IppRegExpState* pRegExpState ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpFind_8u
// Purpose: Looks for the occurrences of the substrings matching
// the specified regular expression.
//
// Parameters:
// pSrc Pointer to the source string
// srcLen Number of elements in the source string.
// pRegExpState Pointer to the structure containing internal form of
// a regular expression
// pFind Array of pointers to the matching substrings
// pNumFind Size of the array pFind on input,
// number of matching substrings on output.
//
// Return:
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr Length of the source vector is less zero or or
// pNumFind is less than or equal to 0
// ippStsRegExpErr The structure pRegExpState contains wrong data
// ippStsRegExpMatchLimitErr The match limit has been exhausted
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpFind_8u, ( const Ipp8u* pSrc, int srcLen, IppRegExpState* pRegExpState,
IppRegExpFind* pFind, int* pNumFind ))
#if !defined( _OWN_BLDPCS )
struct RegExpMultiState;
typedef struct RegExpMultiState IppRegExpMultiState;
typedef struct {
Ipp32u regexpDoneFlag;
Ipp32u regexpID;
Ipp32s numMultiFind;
IppStatus status;
IppRegExpFind* pFind;
} IppRegExpMultiFind;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMultiGetSize
// Purpose: Computes the size of necessary memory (in bytes) for
// structure containing internal form of multi patterns search engine.
//
// Parameters:
// maxPatterns Maximum number of pattern.
// pSize Pointer to the computed size of structure containing
// internal form of search engine
//
// Return:
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr When maxPatterns is less or equal 0.
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpMultiGetSize, ( Ipp32u maxPatterns, int *pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMultiInit
// Purpose: Initialize internal form of multi patterns search engine.
//
// Parameters:
// maxPatterns Maximum number of pattern.
// pState Pointer to the structure containing internal form of
// multi patterns search engine.
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr When maxPatterns is less or equal 0.
//
*/
IPPAPI(IppStatus, ippsRegExpMultiInit, ( IppRegExpMultiState* pState, Ipp32u maxPatterns))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMultiInitAlloc
// Purpose: Allocates necessary memory, initialize internal form of multi patterns search engine
//
// Parameters:
// maxPatterns Maximum number of pattern.
// pState Double pointer to the structure containing internal form of
// multi patterns search engine.
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr When maxPatterns is less or equal 0.
*/
IPPAPI(IppStatus, ippsRegExpMultiInitAlloc, ( IppRegExpMultiState** ppState, Ipp32u maxPatterns))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMultiFree
// Purpose: Frees allocated memory for the structure containing
// internal form of multi patterns search engine
//
// Parameters:
// pState Pointer to the structure containing internal form of
// multi patterns search engine.
//
*/
IPPAPI(void, ippsRegExpMultiFree, (IppRegExpMultiState* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMulti*
// Purpose: Controls multi patterns database. Add, remove or modify patterns.
//
// Parameters:
// pRegExpState Pointer to the structure containing internal form of a
// compiled regular expression.
// regexpID Pattern ID. 0 is invalid ID.
// pState Pointer to the structure containing internal form of
// multi patterns search engine.
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr When ID is equal 0.
// ippStsMemAllocErr When number of patterns exceeded its maximum value.
//
*/
IPPAPI(IppStatus, ippsRegExpMultiAdd, ( const IppRegExpState* pRegExpState, Ipp32u regexpID, IppRegExpMultiState* pState))
IPPAPI(IppStatus, ippsRegExpMultiModify, ( const IppRegExpState* pRegExpState, Ipp32u regexpID, IppRegExpMultiState* pState))
IPPAPI(IppStatus, ippsRegExpMultiDelete, (Ipp32u regexpID, IppRegExpMultiState* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpMultiFind_8u
// Purpose: Looks for the occurrences of the substrings matching
// the specified patterns.
//
// Parameters:
// pSrc Pointer to the source string
// srcLen Number of elements in the source string.
// pState Pointer to the structure containing internal form of
// multi patterns search engine
// pDstMultiFind Array of pointers to the matching patterns
//
// Return:
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsSizeErr Length of the source vector is less or equal zero.
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpMultiFind_8u, ( const Ipp8u* pSrc, int srcLen, IppRegExpMultiFind *pDstMultiFind, const IppRegExpMultiState* pState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsConvertUTF
// Purpose: Convert UTF16BE or UTF16LE format to UTF8 and vice versa.
//
// Parameters:
// pSrc Pointer to the input vector.
// pSrcLen Length of the pSrc vector on input and its used length on output.
// BEFlag Flag to indicate UTF16BE format. 0 means UTF16LE format.
// pDst Pointer to the output vector.
// pDstLen Length of the pDst vector on input and its used length on output.
//
// Return:
// ippStsNullPtrErr One or several pointer(s) is NULL
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ippsConvertUTF_8u16u,( const Ipp8u* pSrc, Ipp32u *pSrcLen, Ipp16u* pDst, Ipp32u *pDstLen, int BEFlag))
IPPAPI(IppStatus, ippsConvertUTF_16u8u,( const Ipp16u* pSrc, Ipp32u *pSrcLen, Ipp8u* pDst, Ipp32u *pDstLen, int BEFlag))
#if !defined( _OWN_BLDPCS )
struct RegExpMultiState;
typedef struct RegExpReplaceState IppRegExpReplaceState;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpReplaceGetSize
// Purpose: Computes the size the find and replace engine memory.
//
// Parameters:
// pSrcReplacement Pointer to the input null-terminated replace pattern.
// pSize Pointer to the computed size of the replace engine memory.
//
// Return:
// ippStsNullPtrErr pSize pointer is NULL
// ippStsNoErr No errors
//
*/
IPPAPI(IppStatus, ippsRegExpReplaceGetSize, ( const Ipp8u* pSrcReplacement, Ipp32u *pSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpReplaceInit
// Purpose: Initialize internal form of find and replace engine.
//
// Parameters:
// pSrcReplacement Pointer to the input null-terminated replace pattern.
// pReplaceState Pointer to the memory allocated for the find and replace
// engine structure of size after ippsRegExpReplaceGetSize function.
//
// Return:
// ippStsNoErr No errors
// ippStsNullPtrErr pReplaceState pointer is NULL
//
*/
IPPAPI(IppStatus, ippsRegExpReplaceInit, ( const Ipp8u* pSrcReplacement, IppRegExpReplaceState *pReplaceState))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippsRegExpReplace_8u
// Purpose: Performs find and replace.
//
// Parameters:
// pSrc Pointer to the source string.
// pSrcLenOffset Length of the pSrc vector on input and its used length on output.
// pRegExpState Pointer to the compiled pattern structure.
// pReplaceState Pointer to the memory allocated for the find and replace engine structure.
// pDst Pointer to the destination string.
// pDstLen Length of the pDst vector on input and its used length on output.
// pFind Array of pointers to the matching substrings.
// pNumFind Size of the array pFind on input, number of matching substrings on output.
//
// Return:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr One or several pointer(s) is NULL.
// ippStsSizeErr Indicates an error when value in pSrcLen or pDstLen is less or equal to zero.
//
*/
IPPAPI(IppStatus, ippsRegExpReplace_8u, ( const Ipp8u* pSrc, int *pSrcLenOffset, Ipp8u *pDst, int *pDstLen, IppRegExpFind* pFind, int* pNumFind, IppRegExpState* pRegExpState,
IppRegExpReplaceState *pReplaceState ))
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#ifdef __cplusplus
}
#endif
#endif /* __IPPCH_H__ */
/* ////////////////////////////// End of file /////////////////////////////// */