muPP API Reference
1 Introduction
The Moore Threads® MUSA® Performance Primitives( muPP ) is a library that provides highly optimized functions for two-dimensional (2D) image, signal processing. The image processing library MUPPI is a set of low-overhead, high-performance operations performed on 2D arrays of pixels. In the future, muPP will cover more of the compute- heavy tasks in a variety of problem domains. The muPP library is created to ensure excellent performance while maximizing flexibility.
To use the muPP library, you can choose either way as follows:
- A stand-alone library for adding GPU acceleration to an application with minimal effort.
- A cooperative library for interoperating with a developer's GPU code efficiently. Both ways allow programmers to develop faster while taking advantage of the powerful processing capabilities of Moore Threads GPUs.
This manual explains the concepts, as well as specific data type definitions, and provides detailed descriptions of the image processing functions. For details, including calling syntax, see the Module Documentation.
1.1 What's new
First release with the following capabilities.
- Arithmetic Operations, including:
- SubC, DivC, and AddC for 1/3 channel 32-bit float images, both inplace and not inplace are supported.
- Alpha compose for 1/4 channel 32-bit float images.
- Color Conversion Operations, including:
- Conversion between RGB and Grayscale for 32-bit float images.
- Conversion between RGB and RGBA for both 8-bit unsigned integer and 32-bit float images.
- Conversion between RGB/BGR and YUV for 32-bit float images.
- Duplicates channel for 1 channel 32-bit float images.
- Adjust brightness, hue, and saturation for 1/3 channel 32-bit float images.
- Data Exchange and Initialization Operations, including:
- Copies and crops for 1/3 channel 32-bit float images.
- Swaps channels for 8-bit unsigned integer and 32-bit float images.
- Sets and masked sets for 1/3 channel 8-bit unsigned integer and 32-bit float images.
- Geometry Operations, including:
- Resizes and rotates for 1/3 channel 32-bit float images.
- Mirrors for 1/3 channel 32-bit float images, both inplace and not inplace are supported.
- Warps affine and warps perspective for 1/3 channel 32-bit float images.
- Scales up and down between 3 channels 8-bit unsigned integer and 32-bit float images.
- Statistical Operations, including:
- MinMax and Norm calculation for 1/3 channel 32-bit float images.
- Normalizes for 1/3 channel 32-bit float images.
- Filter Operations, including:
- Median Filter for 1/3 channel 32-bit float images.
- Gaussian Filter for 1/3 channel 32-bit float images.
2 General API conventions
2.1 Memory management
The design of all the muPP functions follows the same guidelines as other MT MUSA libraries like muFFT and muBLAS. In those APIs, all pointer arguments are device pointers.
This convention enables the individual developer to make smart choices about memory management that minimize the number of memory transfers. It also allows the user the maximum flexibility regarding which of the various memory transfer mechanisms offered by the MUSA runtime is used, such as synchronous or asynchronous memory transfers, pinned memory, etc.
The most basic steps to process data using muPP are as below:
- Transfers input data from the host to the device using musaMemCpy(...)
- Processes data using one or several muPP functions or custom MUSA kernels.
- Transfers the result data from the device to the host using musaMemCpy(...)
2.1.1 Scratch buffer and host pointer
Scratch buffers are used for computations in some muPP functions. It is the user's duty to allocate and delete temporary buffers to maximize control regarding memory allocations and performance. For one this has the ben- efit that the library will not allocate memory unbeknownst to the user. It also allows developers who invoke the same primitive repeatedly to allocate the scratch only once, improving performance and potential device-memory fragmentation.
Scratch-buffer memory is unstructured and may be passed to the primitive in uninitialized form. This allows for the reuse of the same scratch buffers with any primitive require scratch memory, as long as it is sufficiently sized.
The minimum scratch buffer size for a given primitive can be obtained by a companion function. The buffer size is returned via a host pointer as allocation of the scratch buffer is performed via MUSA runtime host code.
2.2 Rounding modes
Many muPP routines need to convert floating-point values to integers. The MUppRoundMode type lists the rounding mode that supports in muPP function. Not all primitives in muPP that perform rounding as part of their functionality allow developers to specify the round mode used. Instead, they use muPP's MUPP_RND_FINANCIAL default rounding mode.
3 Image-Processing API conventions
3.1 Suffix
Image processing functions accept a name followed by a number of suffixes, which describe additional details of the operation. The following abbreviations are used for the suffixes:
API suffixes Description
”A” If the image is a 4-channel image this indicates the alpha channel is not processed.
”Cn” The image consists of n channel-packed pixels, where n can be 1, 2, 3, or 4.
”Pn” The image consists of n separate image planes, where n can be 1, 2, 3, or 4.
”C” The operation is performed only on the “channel-of-interest”.
”I” The operation is performed "in-place". In this case, the image-data pointer is usually named
pSrcDstto indicate that the image data is both source and destination.
”M” A masked operation. These primitives have an additional "mask image" as input. Each pixel in
the destination image corresponds to a pixel in the mask image. Only pixels with a correspond-
ing non-zero mask pixel are being processed.
”R” The primitive operates only on a rectangular region_of_interest or “ROI”.
”Sfs” The primitive operates with fixed scaling and saturation.
The suffixes above always appear in alphabetical order. For example, the function "muppiNV12ToBGR_8u_P2C3R" means 2-channel 8-bit unsigned planar NV12 to 3-channel 8-bit unsigned packed BGR color conversion.
3.2 Parameter names for image data
This section describes three common cases of image data passing throughout muPP.
3.2.1 Passing Source-Image data
Those are images consumed by the algorithm.
3.2.1.1 Source-Image pointer
The source image data is usually passed via a pointer namedpSrc. Usually, the source image pointer is generally defined as constant. Enforcing that the primitive does not change any image data pointed to by that pointer.
If the primitive consumes multiple images as inputs the source pointers are numbered like this: pSrc1, pScr2, ...
3.2.1.2 Source-Image line steps
The source image line step is the number of bytes between successive rows in the image. The source image line step parameter isnSrcStep, or in the case of multiple source images nSrcStep1, nSrcStep2, ...
3.2.1.3 Source-Planar-Image pointer
The multiple plane source image data is passed via a set of pointers named pSrc1, pScr2, ...
3.2.1.4 Source-Planar-Image line step array
The source planar image line step array is an array where each element of the array contains the number of bytes between successive rows for a particular plane in the input image. The source planar image line step array parameter isrSrcStep[].
3.2.2 Passing Destination-Image data
Those are images produced by the algorithm.
3.2.2.1 Destination-Image pointer
The destination image data is usually passed via a pointer namedpDst. If the primitive generates multiple images as outputs the destination pointers are numbered like this: pDst1, pDst2, ...
3.2.2.2 Destination-Image line step
The destination image line step parameter isnDstStep, or in the case of multiple destination images nDstStep1, nDstStep2, ...
3.2.2.3 Destination-Planar-Image pointer array
The planar destination image data pointers are generally passed via an array of pointers namedpDst[]. Each pointer in the array points to a different image plane.
3.2.2.4 Destination-Planar-Image line step array
The destination planar image line step array is an array where each element of the array contains the number of bytes between successive rows for a particular plane in the output image. The destination planar image line step array parameter isrDstStep[].
3.2.3 Passing In-Place image data
3.2.3.1 In-Place image pointer
In the case of in-place processing, the source and destination are served by the same pointer and thus pointers to in-place image data are named:pSrcDst.
3.2.3.2 In-Place-Image line step
The in-place line step parameter isnSrcDstStep.
3.2.4 Passing Mask-Image data
Some image processing primitives have variants that support Masked Operation.
3.2.4.1 Mask-Image pointer
The mask-image data is generally passed via a pointer namedpMask.
3.2.4.2 Mask-Image line step
The mask-image line step parameter isnMaskStep.
3.2.5 Passing Channel-of-Interest data
Some image processing primitives support Channel-of-Interest API.
3.2.5.1 Channel_of_Interest number
The channel-of-interest data is usually an integer(either 1, 2, or 3 ):nCOI.
3.2.6 Image data related error codes
All MUPPI primitives operating on image data validate the image-data pointer for proper alignment and test that the point is not null. Additionally, they check the line stride for proper alignment and guard against the steps that are less than or equal to 0. If failed validation, it will return one of the following error codes and not execute the primitive:
- MUPP_STEP_ERROR is returned if the data step is 0 or negative.
- MUPP_NOT_EVEN_STEP_ERROR is returned if the line step is not a multiple of the pixel size for 2 and 4 channel images.
- MUPP_NULL_POINTER_ERROR is returned if the image-data pointer is 0 (NULL).
- MUPP_ALIGNMENT_ERROR if the image-data pointer address is not a multiple of the pixel size for 2 and 4 channel images.
3.3 Region-of-Interest (ROI)
In practice processing, processing a rectangular sub-region of an image is more common than processing the entire image. The vast majority of muPP's image processing primitives allow the processing of such subregions, also known as regions of interest or ROIs.
All primitives supporting ROI processing are marked by an "R" in their name suffix. In most cases, the ROI is passed as a single MuppiSize struct, which provides the width and height of the ROI. This raises the question of how the primitive knows where in the image this rectangle of (width, height) is located. The "start pixel" of the ROI is implicitly given by the image-data pointer. That is instead of explicitly passing a pixel coordinate for the upper-left corner (lowest memory address), the user simply offsets the image-data pointers to point to the first pixel of the ROI.
In practice, this means that for an image (pSrc,nSrcStep) and the start-pixel of the ROI is at location (x, y), one would pass: pSrcOffset = pSrc + ynSrcStep + xPixelSize;
as the image-data source to the primitive.PixelSizeis typically computed as: PixelSize = NumberOfColorChannels*sizeof(PixelDataType).
3.3.1 ROI related error codes
All MUPPI primitives operating on ROIs of image data validate the ROI size and the image's step size. If failed validation, it will return one of the following error codes and not execute the primitive:
- MUPP_SIZE_ERROR is returned if either the ROI width or ROI height is negative.
- MUPP_STEP_ERROR is returned if the ROI width exceeds the image's line step. In mathematical terms (widthROI∗PixelSize)>nLinStep indicates an error.
Chapter 4
Signal-Processing API conventions
4.1 Signal data
Signal data is passed to and from MUPPS primitives using a pointer to the signal's data type. This simple method of passing signal data is designed with ease of integration into existing software applications.
- Passing the data pointer rather than a higher-level signal struct enables easy adoption by not requiring a specific signal representation (which may contain total signal size offset or other additional information). This prevents problematic signal data packing and unpacking from the host application to a signal format particular to a MUPP.
4.1.1 Parameter names for image data
This section describes three common cases of signal data passing throughout muPP.
4.1.1.1 Source signal pointer
The source signal data is usually passed through a pointer namedpSrc. The source signal pointer is defined as constant, note that the primitive does not change any signal data pointed to by that pointer. For example: MUPPsPrimitive_32s(const MUPP32s*pSrc, ...)
If the primitive consumes multiple signals as inputs the source pointers are numbered like this: pSrc1, pScr2, ...
4.1.1.2 Destination signal pointer
The destination signal data is usually passed through a pointer namedpDst. If the primitive consumes multiple signals as outputs the destination pointers are numbered like this: pDst1, pDst2, ...
4.1.1.3 In-Place signal pointer
In the case of in-place processing, the source and destination are served by the same pointer and thus pointers to in-place signal data are namedpSrcDst.
4.1.2 Signal data alignment requirements
The signal sample data of MUPP needs to be naturally aligned, that is any pointer MUppType*p;
to a sample in a signal should satisfy: assert(p % sizeof(p) == 0);
4.1.3 Signal data related error codes
All MUPPS primitives operating on signal data validate the signal-data pointer for proper alignment and test that the point is not null.
The primitive is not run if validation is failed and the following errors are returned:
- MUPP_NULL_POINTER_ERROR is returned if the signal-data pointer is 0 (NULL).
- MUPP_ALIGNMENT_ERROR is returned if the signal-data pointer address is not a multiple of the signal’s data-type size.
4.2 Signal length
The MUPPS functions accept anLengthparameter, which instructs the primitive how many samples of the signal starting from the given data pointer are to be processed.
4.2.1 Signal length related error codes
All MUPPS primitives that use a length parameter validate this input. The primitive is not run if validation is failed and the following error code is returned:
- MUPP_SIZE_ERROR is returned if the length is negative.
Module Index
5.1 Modules
Class Index
6.1 Class List
- Chapter
- MUPP Core Functions Here is a list of all modules:
- Type Definitions and Constants
- Basic MUPP Data Types
- Image Arithmetic and Logical Operations
- Arithmetic Operations
- AddC
- SubC
- DivC
- Mul
- Logical Operations
- AndC
- OrC
- XorC
- RShiftC
- LShiftC
- And
- Or
- Xor
- Not
- Alpha Composition
- AlphaComp
- Arithmetic Operations
- Color and Sampling Conversion
- Color Model Conversion
- RGBToRGBA
- RGBAToRGB
- RGBToYUV
- BGRToYUV
- YUVToRGB
- YUVToRGBBatch
- YUVToRGBBatchAdvanced
- YUVToBGR
- YUVToBGRBatch
- YUVToBGRBatchAdvanced
- RGBToYUV422
- Color Model Conversion
- YUV422ToRGB
- YUV422ToRGBBatch
- YUV422ToRGBBatchAdvanced
- YUV422ToBGRBatch
- YUV422ToBGRBatchAdvanced
- RGBToYUV420
- YUV420ToRGB
- YUV420ToRGBBatch
- YUV420ToRGBBatchAdvanced
- NV12ToRGB
- RGBToNV12
- NV21ToRGB
- BGRToYUV420
- YUV420ToBGR
- YUV420ToBGRBatch
- YUV420ToBGRBatchAdvanced
- NV12ToBGR
- BGRToNV12
- NV21ToBGR
- RGBToYCbCr
- YCbCrToRGB
- YCbCrToRGBBatch
- YCbCrToRGBBatchAdvanced
- YCbCrToBGR
- YCbCrToBGRBatch
- YCbCrToBGRBatchAdvanced
- YCbCrToBGR_709CSC
- RGBToYCbCr422
- YCbCr422ToRGB
- YCbCr422ToRGBBatch
- YCbCr422ToRGBBatchAdvanced
- RGBToYCrCb422
- YCrCb422ToRGB
- BGRToYCbCr422
- YCbCr422ToBGR
- YCbCr422ToBGRBatch
- YCbCr422ToBGRBatchAdvanced
- RGBToCbYCr422
- CbYCr422ToRGB
- BGRToCbYCr422
- BGRToCbYCr422_709HDTV
- CbYCr422ToBGR
- CbYCr422ToBGR_709HDTV
- RGBToYCbCr420
- YCbCr420ToRGB
- YCbCr420ToRGBBatch
- YCbCr420ToRGBBatchAdvanced
- RGBToYCrCb420
- YCrCb420ToRGB
- BGRToYCbCr420
- BGRToYCbCr420_709CSC
- BGRToYCbCr420_709HDTV
- BGRToYCrCb420_709CSC
- YCbCr420ToBGR
- YCbCr420ToBGRBatch
- YCbCr420ToBGRBatchAdvanced
- YCbCr420ToBGR_709CSC
- YCbCr420ToBGR_709HDTV
- BGRToYCrCb420
- BGRToYCbCr411
- RGBToYCbCr411
- BGRToYCbCr
- YCbCr411ToBGR
- YCbCr411ToRGB
- RGBToXYZ
- XYZToRGB
- RGBToLUV
- LUVToRGB
- BGRToLab
- LabToBGR
- RGBToYCC
- YCCToRGB
- YCCKToCMYK_JPEG
- CMYK_OR_YCCK_JPEG_TO_RGB
- CMYK_OR_YCCK_JPEG_TO_BGR
- RGBToHLS
- HLSToRGB
- BGRToHLS
- HLSToBGR
- RGBToHSV
- HSVToRGB
- JPEG Color Conversion
- ColorToGray Conversion
- ColorDebayer
- Color Sampling Format
- Color Gamma Correction
- Complement Color Key
- Color Processing
- ColorTwist
- ColorTwistBatch
- ColorLUT
- ColorLUTLinear
- ColorLUTCubic
- ColorLUTTrilinear
- ColorLUTPalette
- Adjust Brightness
- Adjust Hue
- Adjust Saturation
- Image Data Exchange and Initialization
- Image Set Operations
- Set
- Masked Set
- Image Copy Operations
- Crop
- Copy
- Copy Constant Border
- Copy Replicate Border
- Copy Wrap Border
- Scale Bit Depth
- Scale To Higher Bit Depth
- Scale To Lower Bit Depth
- Duplicate Channel
- Transpose
- Swap Channels
- Image Set Operations
- Image Filtering Functions
- 2D Fixed Linear Filters
- FilterBox
- Rank Filters
- FilterMedian
- Fixed Filters
- FilterGauss
- FilterLaplace
- 2D Fixed Linear Filters
- Image Geometry Transforms
- Resize
- ResizeBatch
- Remap
- Rotate
- Rotate Utility Functions
- Rotate
- Mirror
- Affine Transforms
- Affine Transform Utility Functions
- Affine Transform
- Perspective Transform
- Perspective Transform Utility Functions
- Perspective Transform
- Image Linear Transforms
- Fourier Transforms
- Image Morphological Operations
- Dilation
- Erode
- Statistical Operations
- Sum
- Min
- MinIndx
- Max
- MaxIndx
- MinMax
- MinMaxIndx
- Mean
- Mean_StdDev
- Image Norms
- Norm_Inf
- Norm_L1
- Norm_L2
- NormDiff_Inf
- NormDiff_L1
- NormDiff_L2
- NormRel_Inf
- NormRel_L1
- NormRel_L2
- Normalize
- DotProd
- CountInRange.
- MaxEvery
- MinEvery
- Integral
- SqrIntegral
- RectStdDev
- HistogramEven
- HistogramRange
- Image Proximity
- SqrDistanceFull_Norm
- SqrDistanceSame_Norm
- SqrDistanceValid_Norm
- CrossCorrFull_Norm
- CrossCorrSame_Norm
- CrossCorrValid_Norm
- CrossCorrValid
- CrossCorrFull_NormLevel
- CrossCorrSame_NormLevel
- CrossCorrValid_NormLevel.
- Image Quality Index.
- MaximumError.
- AverageError.
- MaximumRelativeError.
- AverageRelativeError.
- IQA.
- IQABatch.
- IQABatchAdvanced.
- Image Threshold and Compare
- Thresholding Operations.
- Threshold Operations.
- Thresholding Operations.
- Signal Arithmetic and Logical
- Arithmetic Operations.
- AddProduct.
- MulC.
- Mul.
- Sub.
- Div.
- Abs.
- Sqr.
- Sqrt.
- Exp.
- Ln.
- Arithmetic Operations.
- Signal Conversion Functions
- Convert.
- Signal Initialization
- Zero.
- Copy.
- Chapter
- MUpp16f Here are the classes, structs, unions and interfaces with brief descriptions:
- MUpp16f_2
- MUPP_ALIGN_16
- MUPP_ALIGN_8
- MUppiBufferDescriptor
- MUppiColorTwistBatchCXR
- MUppiCompressedMarkerLabelsInfo
- MUppiConnectedRegion
- MUppiContourPixelDirectionInfo
- MUppiContourPixelGeometryInfo
- MUppiContourTotalsInfo
- MUppiHaarBuffer
- MUppiHaarClassifier_32f
- MUppiHOGConfig
- MUppiImageDescriptor
- MUppiPoint
- MUppiRect
- MUppiResizeBatchCXR
- MUppiResizeBatchROI_Advanced
- MUppiSize
- MUppLibraryVersion
- MUppPointPolar
- MUppStreamContext
Chapter 7
Module Documentation
7.1 MUPP Core Functions
Functions
- musaStream_t muppGetStream (void) Gets the MUPP MUSA stream.
- MUppStatus muppSetStream (musaStream_t hStream) Sets the MUPP MUSA stream.
7.1.1 Detailed Description
Basic functions for library management, in particular library version and device property query functions.
7.1.2 Function Documentation
7.1.2.1 muppGetStream()
musaStream_t muppGetStream ( void )
Gets the MUPP MUSA stream.
MUPP enables concurrent device tasks via a global stream state variable. The default setting for the MUPP stream is stream 0, i.e. non-concurrent mode. Any valid MUSA stream can be chosen as the MUPP stream. The MUPP stream is then used for any MUSA commands sent by MUPP (e.g. kernels launched by the MUPP library).
7.1.2.2 muppSetStream()
MUppStatus muppSetStream ( musaStream_t hStream)
Sets the MUPP MUSA stream.
If MUSA stream management is not working properly, this function now returns an error. Since unnecessarily flushing the current stream have a major negative impact on performance, this function should only be called if a call to muppGetStream() returns a stream number that is different from the desired stream.
7.2 Type Definitions and Constants
Modules
- Basic MUPP Data Types
Classes
- struct MUppLibraryVersion
Enumerations
- enum MUppiInterpolationMode {
**MUPPI_INTER_UNDEFINED** = 0 ,
MUPPI_INTER_NN = 1 ,
MUPPI_INTER_LINEAR = 2 ,
MUPPI_INTER_CUBIC = 4 ,
MUPPI_INTER_CUBIC2P_BSPLINE ,
MUPPI_INTER_CUBIC2P_CATMULLROM ,
MUPPI_INTER_CUBIC2P_B05C03 ,
MUPPI_INTER_SUPER = 8 ,
MUPPI_INTER_LANCZOS = 16 ,
MUPPI_INTER_LANCZOS3_ADVANCED = 17 ,
MUPPI_SMOOTH_EDGE = reinterpret_cast<int>(0x8000000) }
- enum MUppiCopyPaddingMode {
NONE ,
CONSTANT ,
REPLICATE ,
WRAP }
- enum MUppiBayerGridPosition {
MUPPI_BAYER_BGGR = 0 ,
**MUPPI_BAYER_RGGB** = 1 ,
**MUPPI_BAYER_GBRG** = 2 ,
**MUPPI_BAYER_GRBG** = 3 }
- enum MUppiMaskSize {
**MUPP_MASK_SIZE_1_X_3** ,
**MUPP_MASK_SIZE_1_X_5** ,
MUPP_MASK_SIZE_3_X_1 = 100 ,
**MUPP_MASK_SIZE_5_X_1** ,
MUPP_MASK_SIZE_3_X_3 = 200 ,
**MUPP_MASK_SIZE_5_X_5** ,
**MUPP_MASK_SIZE_7_X_7** = 400 ,
**MUPP_MASK_SIZE_9_X_9** = 500 ,
**MUPP_MASK_SIZE_11_X_11** = 600 ,
**MUPP_MASK_SIZE_13_X_13** = 700 ,
**MUPP_MASK_SIZE_15_X_15** = 800 }
- enum MUppiDifferentialKernel {
**MUPP_FILTER_SOBEL** ,
**MUPP_FILTER_SCHARR** }
- enum MUppStatus {
**MUPP_NOT_SUPPORTED_MODE_ERROR** = -9999 ,
**MUPP_INVALID_HOST_POINTER_ERROR** = -1032 ,
**MUPP_INVALID_DEVICE_POINTER_ERROR** = -1031 ,
**MUPP_LUT_PALETTE_BITSIZE_ERROR** = -1030 ,
MUPP_ZC_MODE_NOT_SUPPORTED_ERROR = -1028 ,
**MUPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY** = -1027 ,
**MUPP_TEXTURE_BIND_ERROR** = -1024 ,
**MUPP_WRONG_INTERSECTION_ROI_ERROR** = -1020 ,
**MUPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR** = -1006 ,
**MUPP_MEMFREE_ERROR** = -1005 ,
**MUPP_MEMSET_ERROR** = -1004 ,
**MUPP_MEMCPY_ERROR** = -1003 ,
**MUPP_ALIGNMENT_ERROR** = -1002 ,
**MUPP_MUSA_KERNEL_EXECUTION_ERROR** = -1000 ,
MUPP_ROUND_MODE_NOT_SUPPORTED_ERROR = -213 ,
MUPP_QUALITY_INDEX_ERROR = -210 ,
MUPP_RESIZE_NO_OPERATION_ERROR = -201 ,
MUPP_OVERFLOW_ERROR = -109 ,
MUPP_NOT_EVEN_STEP_ERROR = -108 ,
MUPP_HISTOGRAM_NUMBER_OF_LEVELS_ERROR = -107 ,
MUPP_LUT_NUMBER_OF_LEVELS_ERROR = -106 ,
MUPP_CORRUPTED_DATA_ERROR = -61 ,
MUPP_CHANNEL_ORDER_ERROR = -60 ,
MUPP_ZERO_MASK_VALUE_ERROR = -59 ,
MUPP_QUADRANGLE_ERROR = -58 ,
MUPP_RECTANGLE_ERROR = -57 ,
MUPP_COEFFICIENT_ERROR = -56 ,
MUPP_NUMBER_OF_CHANNELS_ERROR = -53 ,
MUPP_COI_ERROR = -52 ,
MUPP_DIVISOR_ERROR = -51 ,
MUPP_CHANNEL_ERROR = -47 ,
MUPP_STRIDE_ERROR = -37 ,
MUPP_ANCHOR_ERROR = -34 ,
MUPP_MASK_SIZE_ERROR = -33 ,
**MUPP_RESIZE_FACTOR_ERROR** = -23 ,
**MUPP_INTERPOLATION_ERROR** = -22 ,
**MUPP_MIRROR_FLIP_ERROR** = -21 ,
**MUPP_MOMENT_00_ZERO_ERROR** = -20 ,
**MUPP_THRESHOLD_NEGATIVE_LEVEL_ERROR** = -19 ,
**MUPP_THRESHOLD_ERROR** = -18 ,
**MUPP_CONTEXT_MATCH_ERROR** = -17 ,
**MUPP_FFT_FLAG_ERROR** = -16 ,