Function Naming and Parameters

         ipp<data-domain><name>[_<datatype>][_<descriptor>](<parameters>);

Data-Domain

The data-domain is a single character indicating type of the input data. The current version of Intel IPP supports the following data-domains:

         s

for signals (expected data type is a 1D array)

         g

for signals of the fixed length (expected data type is a 1D array)

         i

for images and video (expected data type is a 2D array of pixels)

         m

for vectors and matrices (expected data type is a matrix or vector)

         r

for realistic rendering functionality and 3D data processing (expected data type depends on supported rendering techniques)

The core functions in Intel IPP do not operate on one of these types of the input data (see Core Functions). These functions have ipp as a prefix without the data-domain field, for example, ippGetStatusString.

Name

The name identifies the algorithm or operation that the function does. It has the following format:

         <name> = <operation>[_modifier]

The operation field is one or more words, acronyms, and abbreviations that identify the base operation, for example Set, DCTFwd. If the operation consists of several parts, each part starts with an uppercase character without underscore, for example, HilbertInitAlloc.

The modifier, if present, denotes a slight modification or variation of the given function. For example, the modifier CToC in the function ippsFFTInv_CToC_32fc signifies that the inverse fast Fourier transform operates on complex data, performing complex-to-complex (CToC) transform. Functions for matrix operation have and object type description as a modifier, for example, ippmMul_mv - multiplication of a matrix by a vector.

Data Types

The datatype field indicates data types used by the function in the following format:

         <datatype> = <bit_depth><bit_interpretation>

where

               bit_depth = <1|8|16|32|64>

and

         bit_interpretation = < u|s|f>[c]

Here u indicates "unsigned integer", s indicates "signed integer", f indicates "floating point", and c indicates "complex".

For functions that operate on a single data type, the datatype field contains only one value.

If a function operates on source and destination objects that have different data types, the respective data type identifiers are listed in the function name in order of source and destination as follows:

  <datatype> = <src1Datatype>[src2Datatype][dstDatatype]

For example, the function ippsDotProd_16s16sc computes the dot product of 16-bit short and 16-bit complex short source vectors and stores the result in a 16-bit complex short destination vector. The dstDatatype modifier is not present in the name because the second operand and the result are of the same type.

Descriptor

The optional descriptor field describes the data associated with the operation. It can contain implied parameters and/or indicate additional required parameters.

To minimize the number of code branches in the function and thus reduce potentially unnecessary execution overhead, most of the general functions are split into separate primitive functions, with some of their parameters entering the primitive function name as descriptors.

However, general functions with large number of permutations may still have parameters that determine internal operation (for example, ippiThreshold).

The following descriptors are used in Intel IPP:

The descriptors in function names are always presented in alphabetical order.

Some data descriptors are implied as "default" for certain operations. Such descriptors are not added to the function names. For example, the image processing functions always operate on a two-dimensional image and saturate the results without scaling them. In these cases, the implied descriptors D2 (two-dimensional signal) and s (saturation and no scaling) are not included in the function name.

Parameters

The parameters field specifies the function parameters (arguments).

The order of parameters is as follows:

1. All source operands. Constants follow arrays

2. All destination operands. Constants follow arrays

3. Other, operation-specific parameters

The parameter's name has the following conventions:

• All arguments defined as pointers start with p, for example, pPhase, pSrc, pSeed; arguments defined as double pointers start with pp, for example, ppState; and arguments defined as values start with a lowercase letter, for example, val, src, srcLen.

• Each new part of an argument name starts with an uppercase character, without underscore, for example, pSrc, lenSrc, pDlyLine.

• Each argument name specifies its functionality. Source arguments are named pSrc or src, sometimes followed by numbers or names, for example, pSrc2, srcLen. Output arguments are named pDst or dst, sometimes followed by numbers or names, for example, pDst1, dstLen. For in-place operations, the input/output argument contains the name pSrcDst.

Examples of function syntax:

• ippsIIR_32f_I(Ipp32f* pSrcDst, int len, IppsIIRState_32f* pState);

• ippiConvert_8u1u_C1R(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, int dstBitOffset, IppiSize roiSize, Ipp8u threshold);

• ippmSub_vac_32f(const Ipp32f* pSrc, int srcStride0, int srcStride2, Ipp32f val, Ipp32f* pDst, int dstStride0, int dstStride2, int len, int count);