nppdefs.h

 /* Copyright 2009-2022 NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
  * 
  * NOTICE TO LICENSEE: 
  * 
  * The source code and/or documentation ("Licensed Deliverables") are 
  * subject to NVIDIA intellectual property rights under U.S. and 
  * international Copyright laws. 
  * 
  * The Licensed Deliverables contained herein are PROPRIETARY and 
  * CONFIDENTIAL to NVIDIA and are being provided under the terms and 
  * conditions of a form of NVIDIA software license agreement by and 
  * between NVIDIA and Licensee ("License Agreement") or electronically 
  * accepted by Licensee.  Notwithstanding any terms or conditions to 
  * the contrary in the License Agreement, reproduction or disclosure 
  * of the Licensed Deliverables to any third party without the express 
  * written consent of NVIDIA is prohibited. 
  * 
  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE 
  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE 
  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  THEY ARE 
  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND. 
  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED 
  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, 
  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. 
  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE 
  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY 
  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY 
  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  * OF THESE LICENSED DELIVERABLES. 
  * 
  * U.S. Government End Users.  These Licensed Deliverables are a 
  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT 
  * 1995), consisting of "commercial computer software" and "commercial 
  * computer software documentation" as such terms are used in 48 
  * C.F.R. 12.212 (SEPT 1995) and are provided to the U.S. Government 
  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and 
  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all 
  * U.S. Government End Users acquire the Licensed Deliverables with 
  * only those rights set forth herein. 
  * 
  * Any use of the Licensed Deliverables in individual and commercial 
  * software must include, in the user documentation and internal 
  * comments to the code, the above Disclaimer and U.S. Government End 
  * Users Notice. 
  */ 
#ifndef NV_NPPIDEFS_H
#define NV_NPPIDEFS_H

#include <stdlib.h>
#include <cuda_runtime.h>

#ifdef __cplusplus
#ifdef NPP_PLUS
using namespace nppPlusV;
#else
extern "C" {
#endif
#endif

// Workaround for cuda_fp16.h C incompatibility
typedef 
struct
{
   short fp16;
}
Npp16f;

typedef
struct
{
   short fp16_0;
   short fp16_1;
}
Npp16f_2;

#define NPP_HALF_TO_NPP16F(pHalf) (* reinterpret_cast<Npp16f *>((void *)(pHalf)))

// If this is a 32-bit Windows compile, don't align to 16-byte at all
        // and use a "union-trick" to create 8-byte alignment.
#if defined(_WIN32) && !defined(_WIN64)

            // On 32-bit Windows platforms, do not force 8-byte alignment.
            //   This is a consequence of a limitation of that platform.
    #define NPP_ALIGN_8
            // On 32-bit Windows platforms, do not force 16-byte alignment.
            //   This is a consequence of a limitation of that platform.
    #define NPP_ALIGN_16

#else /* _WIN32 && !_WIN64 */

    #define NPP_ALIGN_8     __align__(8)
    #define NPP_ALIGN_16    __align__(16)

#endif /* !__CUDACC__ && _WIN32 && !_WIN64 */


typedef enum 
{
    NPPI_INTER_UNDEFINED         = 0,
    NPPI_INTER_NN                = 1,        
    NPPI_INTER_LINEAR            = 2,        
    NPPI_INTER_CUBIC             = 4,        
    NPPI_INTER_CUBIC2P_BSPLINE,              
    NPPI_INTER_CUBIC2P_CATMULLROM,           
    NPPI_INTER_CUBIC2P_B05C03,               
    NPPI_INTER_SUPER             = 8,        
    NPPI_INTER_LANCZOS           = 16,       
    NPPI_INTER_LANCZOS3_ADVANCED = 17,       
    NPPI_SMOOTH_EDGE             = (int)0x8000000 
} NppiInterpolationMode; 

typedef enum 
{
    NPPI_BAYER_BGGR         = 0,             
    NPPI_BAYER_RGGB         = 1,
    NPPI_BAYER_GBRG         = 2,
    NPPI_BAYER_GRBG         = 3
} NppiBayerGridPosition; 

typedef enum
{
    NPP_MASK_SIZE_1_X_3,
    NPP_MASK_SIZE_1_X_5,
    NPP_MASK_SIZE_3_X_1 = 100, // leaving space for more 1 X N type enum values 
    NPP_MASK_SIZE_5_X_1,
    NPP_MASK_SIZE_3_X_3 = 200, // leaving space for more N X 1 type enum values
    NPP_MASK_SIZE_5_X_5,
    NPP_MASK_SIZE_7_X_7 = 400,
    NPP_MASK_SIZE_9_X_9 = 500,
    NPP_MASK_SIZE_11_X_11 = 600,
    NPP_MASK_SIZE_13_X_13 = 700,
    NPP_MASK_SIZE_15_X_15 = 800
} NppiMaskSize;

typedef enum
{
    NPP_FILTER_SOBEL,
    NPP_FILTER_SCHARR,
} NppiDifferentialKernel;

typedef enum 
{
    /* negative return-codes indicate errors */
    NPP_NOT_SUPPORTED_MODE_ERROR            = -9999,  
    
    NPP_INVALID_HOST_POINTER_ERROR          = -1032,
    NPP_INVALID_DEVICE_POINTER_ERROR        = -1031,
    NPP_LUT_PALETTE_BITSIZE_ERROR           = -1030,
    NPP_ZC_MODE_NOT_SUPPORTED_ERROR         = -1028,      
    NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY   = -1027,
    NPP_TEXTURE_BIND_ERROR                  = -1024,
    NPP_WRONG_INTERSECTION_ROI_ERROR        = -1020,
    NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR   = -1006,
    NPP_MEMFREE_ERROR                       = -1005,
    NPP_MEMSET_ERROR                        = -1004,
    NPP_MEMCPY_ERROR                        = -1003,
    NPP_ALIGNMENT_ERROR                     = -1002,
    NPP_CUDA_KERNEL_EXECUTION_ERROR         = -1000,

    NPP_ROUND_MODE_NOT_SUPPORTED_ERROR      = -213,     
    NPP_QUALITY_INDEX_ERROR                 = -210,     
    NPP_RESIZE_NO_OPERATION_ERROR           = -201,     
    NPP_OVERFLOW_ERROR                      = -109,     
    NPP_NOT_EVEN_STEP_ERROR                 = -108,     
    NPP_HISTOGRAM_NUMBER_OF_LEVELS_ERROR    = -107,     
    NPP_LUT_NUMBER_OF_LEVELS_ERROR          = -106,     
    NPP_CORRUPTED_DATA_ERROR                = -61,      
    NPP_CHANNEL_ORDER_ERROR                 = -60,      
    NPP_ZERO_MASK_VALUE_ERROR               = -59,      
    NPP_QUADRANGLE_ERROR                    = -58,      
    NPP_RECTANGLE_ERROR                     = -57,      
    NPP_COEFFICIENT_ERROR                   = -56,      
    NPP_NUMBER_OF_CHANNELS_ERROR            = -53,      
    NPP_COI_ERROR                           = -52,      
    NPP_DIVISOR_ERROR                       = -51,      
    NPP_CHANNEL_ERROR                       = -47,      
    NPP_STRIDE_ERROR                        = -37,      
    NPP_ANCHOR_ERROR                        = -34,      
    NPP_MASK_SIZE_ERROR                     = -33,      
    NPP_RESIZE_FACTOR_ERROR                 = -23,
    NPP_INTERPOLATION_ERROR                 = -22,
    NPP_MIRROR_FLIP_ERROR                   = -21,
    NPP_MOMENT_00_ZERO_ERROR                = -20,
    NPP_THRESHOLD_NEGATIVE_LEVEL_ERROR      = -19,
    NPP_THRESHOLD_ERROR                     = -18,
    NPP_CONTEXT_MATCH_ERROR                 = -17,
    NPP_FFT_FLAG_ERROR                      = -16,
    NPP_FFT_ORDER_ERROR                     = -15,
    NPP_STEP_ERROR                          = -14,       
    NPP_SCALE_RANGE_ERROR                   = -13,
    NPP_DATA_TYPE_ERROR                     = -12,
    NPP_OUT_OFF_RANGE_ERROR                 = -11,
    NPP_DIVIDE_BY_ZERO_ERROR                = -10,
    NPP_MEMORY_ALLOCATION_ERR               = -9,
    NPP_NULL_POINTER_ERROR                  = -8,
    NPP_RANGE_ERROR                         = -7,
    NPP_SIZE_ERROR                          = -6,
    NPP_BAD_ARGUMENT_ERROR                  = -5,
    NPP_NO_MEMORY_ERROR                     = -4,
    NPP_NOT_IMPLEMENTED_ERROR               = -3,
    NPP_ERROR                               = -2,
    NPP_ERROR_RESERVED                      = -1,
    
    /* success */
    NPP_NO_ERROR                            = 0,        
    NPP_SUCCESS = NPP_NO_ERROR,                         
    /* positive return-codes indicate warnings */
    NPP_NO_OPERATION_WARNING                = 1,        
    NPP_DIVIDE_BY_ZERO_WARNING              = 6,        
    NPP_AFFINE_QUAD_INCORRECT_WARNING       = 28,       
    NPP_WRONG_INTERSECTION_ROI_WARNING      = 29,       
    NPP_WRONG_INTERSECTION_QUAD_WARNING     = 30,       
    NPP_DOUBLE_SIZE_WARNING                 = 35,       
    NPP_MISALIGNED_DST_ROI_WARNING          = 10000,    
} NppStatus;

typedef struct 
{
    int    major;   
    int    minor;   
    int    build;   
} NppLibraryVersion;

typedef unsigned char       Npp8u;     
typedef signed char         Npp8s;     
typedef unsigned short      Npp16u;    
typedef short               Npp16s;    
typedef unsigned int        Npp32u;    
typedef int                 Npp32s;    
typedef unsigned long long  Npp64u;    
typedef long long           Npp64s;    
typedef float               Npp32f;    
typedef double              Npp64f;    
typedef struct __align__(2)
{
    Npp8u  re;     
    Npp8u  im;     
} Npp8uc;

typedef struct __align__(4)
{
    Npp16u  re;     
    Npp16u  im;     
} Npp16uc;

typedef struct __align__(4)
{
    Npp16s  re;     
    Npp16s  im;     
} Npp16sc;

typedef struct NPP_ALIGN_8
{
    Npp32u  re;     
    Npp32u  im;     
} Npp32uc;

typedef struct NPP_ALIGN_8
{
    Npp32s  re;     
    Npp32s  im;     
} Npp32sc;

typedef struct NPP_ALIGN_8
{
    Npp32f  re;     
    Npp32f  im;     
} Npp32fc;

typedef struct NPP_ALIGN_16
{
    Npp64s  re;     
    Npp64s  im;     
} Npp64sc;

typedef struct NPP_ALIGN_16
{
    Npp64f  re;     
    Npp64f  im;     
} Npp64fc;



typedef enum
{
    NPP_8U,
    NPP_8S,
    NPP_16U,
    NPP_16S,
    NPP_32U,
    NPP_32S,
    NPP_64U,
    NPP_64S,
    NPP_16F,
    NPP_32F,
    NPP_64F
} NppDataType;

typedef enum
{
    NPP_CH_1,
    NPP_CH_2,
    NPP_CH_3,
    NPP_CH_4,
    NPP_CH_A4,
    NPP_CH_P3,
    NPP_CH_P4
} NppiChannels;
#define NPP_MIN_8U      ( 0 )                        
#define NPP_MAX_8U      ( 255 )                      
#define NPP_MIN_16U     ( 0 )                        
#define NPP_MAX_16U     ( 65535 )                    
#define NPP_MIN_32U     ( 0 )                        
#define NPP_MAX_32U     ( 4294967295U )              
#define NPP_MIN_64U     ( 0 )                        
#define NPP_MAX_64U     ( 18446744073709551615ULL )  
#define NPP_MIN_8S      (-127 - 1 )                  
#define NPP_MAX_8S      ( 127 )                      
#define NPP_MIN_16S     (-32767 - 1 )                
#define NPP_MAX_16S     ( 32767 )                    
#define NPP_MIN_32S     (-2147483647 - 1 )           
#define NPP_MAX_32S     ( 2147483647 )               
#define NPP_MAX_64S     ( 9223372036854775807LL )    
#define NPP_MIN_64S     (-9223372036854775807LL - 1) 
#define NPP_MINABS_32F  ( 1.175494351e-38f )         
#define NPP_MAXABS_32F  ( 3.402823466e+38f )         
#define NPP_MINABS_64F  ( 2.2250738585072014e-308 )  
#define NPP_MAXABS_64F  ( 1.7976931348623158e+308 )  
typedef struct 
{
    int x;      
    int y;      
} NppiPoint;

typedef struct 
{
    Npp32f x;      
    Npp32f y;      
} NppiPoint32f;

typedef struct 
{
    Npp64f x;      
    Npp64f y;      
} NppiPoint64f;

typedef struct {
    Npp32f rho;
    Npp32f theta;
} NppPointPolar;

typedef struct 
{
    int width;  
    int height; 
} NppiSize;

typedef struct
{
    int x;          
    int y;          
    int width;      
    int height;     
} NppiRect;

typedef enum 
{
    NPP_HORIZONTAL_AXIS,
    NPP_VERTICAL_AXIS,
    NPP_BOTH_AXIS
} NppiAxis;

typedef enum 
{
    NPP_CMP_LESS,
    NPP_CMP_LESS_EQ,
    NPP_CMP_EQ,
    NPP_CMP_GREATER_EQ,
    NPP_CMP_GREATER
} NppCmpOp;

typedef enum 
{
    NPP_RND_NEAR,
    NPP_ROUND_NEAREST_TIES_TO_EVEN = NPP_RND_NEAR, 

    NPP_RND_FINANCIAL,
    NPP_ROUND_NEAREST_TIES_AWAY_FROM_ZERO = NPP_RND_FINANCIAL, 

    NPP_RND_ZERO,
    NPP_ROUND_TOWARD_ZERO = NPP_RND_ZERO, 
    
    /*
     * Other rounding modes supported by IEEE-754 (2008) floating-point standard:
     *
     * - NPP_ROUND_TOWARD_INFINITY // ceiling
     * - NPP_ROUND_TOWARD_NEGATIVE_INFINITY // floor
     *
     */
} NppRoundMode;

typedef enum  
{
    NPP_BORDER_UNDEFINED        = 0,
    NPP_BORDER_NONE             = NPP_BORDER_UNDEFINED, 
    NPP_BORDER_CONSTANT         = 1,
    NPP_BORDER_REPLICATE        = 2,
    NPP_BORDER_WRAP             = 3,
    NPP_BORDER_MIRROR           = 4
} NppiBorderType;


typedef enum {
    NPP_ALG_HINT_NONE,
    NPP_ALG_HINT_FAST,
    NPP_ALG_HINT_ACCURATE
} NppHintAlgorithm;

/* 
 * Alpha composition controls. 
 */

typedef enum {
    NPPI_OP_ALPHA_OVER,
    NPPI_OP_ALPHA_IN,
    NPPI_OP_ALPHA_OUT,
    NPPI_OP_ALPHA_ATOP,
    NPPI_OP_ALPHA_XOR,
    NPPI_OP_ALPHA_PLUS,
    NPPI_OP_ALPHA_OVER_PREMUL,
    NPPI_OP_ALPHA_IN_PREMUL,
    NPPI_OP_ALPHA_OUT_PREMUL,
    NPPI_OP_ALPHA_ATOP_PREMUL,
    NPPI_OP_ALPHA_XOR_PREMUL,
    NPPI_OP_ALPHA_PLUS_PREMUL,
    NPPI_OP_ALPHA_PREMUL
} NppiAlphaOp;


typedef struct 
{
    int      cellSize;             
    int      histogramBlockSize;   
    int      nHistogramBins;       
    NppiSize detectionWindowSize;  
} NppiHOGConfig;

#define NPP_HOG_MAX_CELL_SIZE                          (16) 
#define NPP_HOG_MAX_BLOCK_SIZE                         (64) 
#define NPP_HOG_MAX_BINS_PER_CELL                      (16) 
#define NPP_HOG_MAX_CELLS_PER_DESCRIPTOR              (256) 
#define NPP_HOG_MAX_OVERLAPPING_BLOCKS_PER_DESCRIPTOR (256) 
#define NPP_HOG_MAX_DESCRIPTOR_LOCATIONS_PER_CALL     (128) 
typedef struct
{
    int      numClassifiers;    
    Npp32s * classifiers;       
    size_t   classifierStep;
    NppiSize classifierSize;
    Npp32s * counterDevice;
} NppiHaarClassifier_32f;

typedef struct
{
    int      haarBufferSize;    
    Npp32s * haarBuffer;        
} NppiHaarBuffer;

typedef enum {
    nppZCR,    
    nppZCXor,  
    nppZCC     
} NppsZCType;

typedef enum {
    nppiDCTable,    
    nppiACTable,    
} NppiHuffmanTableType;

typedef enum {
    nppiNormInf = 0, 
    nppiNormL1 = 1,  
    nppiNormL2 = 2   
} NppiNorm;

typedef struct
{
    NppiRect oBoundingBox;       
    Npp32u nConnectedPixelCount; 
    Npp32u aSeedPixelValue[3];   
} NppiConnectedRegion;

typedef struct
{
    void *     pData;  
    int        nStep;  
    NppiSize  oSize;   
} NppiImageDescriptor;


typedef struct
{
    void *     pData;        
    int        nBufferSize;  
} NppiBufferDescriptor;


typedef struct
{
    Npp32u nMarkerLabelPixelCount;           
    Npp32u nContourPixelCount;               
    Npp32u nContourPixelsFound;              
    NppiPoint oContourFirstPixelLocation;    
    NppiRect oMarkerLabelBoundingBox;        
} NppiCompressedMarkerLabelsInfo;


typedef struct
{
    Npp32u nMarkerLabelID;                   
    Npp32u nContourPixelCount;               
    Npp32u nContourStartingPixelOffset;      
    Npp32u nSegmentNum;                      
} NppiContourBlockSegment;


typedef struct
{
    NppiPoint oContourOrderedGeometryLocation;                 
    NppiPoint oContourPrevPixelLocation;                       
    NppiPoint oContourCenterPixelLocation;                     
    NppiPoint oContourNextPixelLocation;                       
    Npp32s nOrderIndex;                                        
    Npp32s nReverseOrderIndex;                                 
    Npp32u nFirstIndex;                                        
    Npp32u nLastIndex;                                         
    Npp32u nNextContourPixelIndex;                             
    Npp32u nPrevContourPixelIndex;                             
    Npp8u nPixelAlreadyUsed;                                   
    Npp8u nAlreadyLinked;                                      
    Npp8u nAlreadyOutput;                                      
    Npp8u nContourInteriorDirection;                           
} NppiContourPixelGeometryInfo;

#define NPP_CONTOUR_DIRECTION_SOUTH_EAST    1
#define NPP_CONTOUR_DIRECTION_SOUTH         2
#define NPP_CONTOUR_DIRECTION_SOUTH_WEST    4
#define NPP_CONTOUR_DIRECTION_WEST          8
#define NPP_CONTOUR_DIRECTION_EAST         16
#define NPP_CONTOUR_DIRECTION_NORTH_EAST   32
#define NPP_CONTOUR_DIRECTION_NORTH        64
#define NPP_CONTOUR_DIRECTION_NORTH_WEST  128

#define NPP_CONTOUR_DIRECTION_ANY_NORTH  NPP_CONTOUR_DIRECTION_NORTH_EAST | NPP_CONTOUR_DIRECTION_NORTH | NPP_CONTOUR_DIRECTION_NORTH_WEST
#define NPP_CONTOUR_DIRECTION_ANY_WEST   NPP_CONTOUR_DIRECTION_NORTH_WEST | NPP_CONTOUR_DIRECTION_WEST | NPP_CONTOUR_DIRECTION_SOUTH_WEST
#define NPP_CONTOUR_DIRECTION_ANY_SOUTH  NPP_CONTOUR_DIRECTION_SOUTH_EAST | NPP_CONTOUR_DIRECTION_SOUTH | NPP_CONTOUR_DIRECTION_SOUTH_WEST
#define NPP_CONTOUR_DIRECTION_ANY_EAST   NPP_CONTOUR_DIRECTION_NORTH_EAST | NPP_CONTOUR_DIRECTION_EAST | NPP_CONTOUR_DIRECTION_SOUTH_EAST

typedef struct
{
    Npp32u  nMarkerLabelID;                         
    Npp8u nContourDirectionCenterPixel;             
    Npp8u nContourInteriorDirectionCenterPixel;     
    Npp8u nConnected;                               
    Npp8u nGeometryInfoIsValid;
    NppiContourPixelGeometryInfo oContourPixelGeometryInfo;
    NppiPoint nEast1, nNorthEast1, nNorth1, nNorthWest1, nWest1, nSouthWest1, nSouth1, nSouthEast1;
    Npp8u nTest1EastConnected;
    Npp8u nTest1NorthEastConnected;
    Npp8u nTest1NorthConnected;
    Npp8u nTest1NorthWestConnected;
    Npp8u nTest1WestConnected;
    Npp8u nTest1SouthWestConnected;
    Npp8u nTest1SouthConnected;
    Npp8u nTest1SouthEastConnected;
} NppiContourPixelDirectionInfo;

typedef struct
{
    Npp32u nTotalImagePixelContourCount;    
    Npp32u nLongestImageContourPixelCount;  
} NppiContourTotalsInfo;


typedef enum 
{
    NPP_WATERSHED_SEGMENT_BOUNDARIES_NONE,
    NPP_WATERSHED_SEGMENT_BOUNDARIES_BLACK,
    NPP_WATERSHED_SEGMENT_BOUNDARIES_WHITE,
    NPP_WATERSHED_SEGMENT_BOUNDARIES_CONTRAST,
    NPP_WATERSHED_SEGMENT_BOUNDARIES_ONLY
} NppiWatershedSegmentBoundaryType;

    
typedef struct
{
    cudaStream_t hStream;
    int nCudaDeviceId; /* From cudaGetDevice() */
    int nMultiProcessorCount; /* From cudaGetDeviceProperties() */
    int nMaxThreadsPerMultiProcessor; /* From cudaGetDeviceProperties() */
    int nMaxThreadsPerBlock; /* From cudaGetDeviceProperties() */
    size_t nSharedMemPerBlock; /* From cudaGetDeviceProperties */
    int nCudaDevAttrComputeCapabilityMajor; /* From cudaGetDeviceAttribute() */
    int nCudaDevAttrComputeCapabilityMinor; /* From cudaGetDeviceAttribute() */
    unsigned int nStreamFlags; /* From cudaStreamGetFlags() */
    int nReserved0;
} NppStreamContext;

#ifdef __cplusplus
#ifndef NPP_PLUS
} /* extern "C" */
#endif
#endif

#endif /* NV_NPPIDEFS_H */