nvxcu.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA Corporation is strictly prohibited.
 */

#ifndef NVXCU_H
#define NVXCU_H

#include <stdint.h>
#include <cuda_runtime_api.h>
#include <NVX/nvx_api_macros.h>

//----------------------------------------------------------------------------
// Generic types
//----------------------------------------------------------------------------

typedef enum _nvxcu_error_status_e {
    NVXCU_ERROR_CUDA_FAILURE          = -1002,  
    NVXCU_ERROR_INVALID_PARAMETERS    = -10,    
    NVXCU_ERROR_NOT_SUPPORTED         = -3,     
    NVXCU_ERROR_NOT_IMPLEMENTED       = -2,     
    NVXCU_FAILURE                     = -1,     
    NVXCU_SUCCESS                     =  0,     
} nvxcu_error_status_e;

typedef enum _nvxcu_array_item_type_e {
    NVXCU_TYPE_CHAR           = 0x001,      
    NVXCU_TYPE_INT8           = 0x002,      
    NVXCU_TYPE_UINT8          = 0x003,      
    NVXCU_TYPE_INT16          = 0x004,      
    NVXCU_TYPE_UINT16         = 0x005,      
    NVXCU_TYPE_INT32          = 0x006,      
    NVXCU_TYPE_UINT32         = 0x007,      
    NVXCU_TYPE_INT64          = 0x008,      
    NVXCU_TYPE_UINT64         = 0x009,      
    NVXCU_TYPE_FLOAT32        = 0x00A,      
    NVXCU_TYPE_FLOAT64        = 0x00B,      
    NVXCU_TYPE_RECTANGLE      = 0x020,      
    NVXCU_TYPE_KEYPOINT       = 0x021,      
    NVXCU_TYPE_COORDINATES2D  = 0x022,      
    NVXCU_TYPE_COORDINATES3D  = 0x023,      
    NVXCU_TYPE_POINT2F        = 0x400,      
    NVXCU_TYPE_POINT3F        = 0x401,      
    NVXCU_TYPE_POINT4F        = 0x402,      
    NVXCU_TYPE_KEYPOINTF      = 0x403,      
} nvxcu_array_item_type_e;

#define NVXCU_DF_IMAGE(a, b, c, d) ((a) | (b << 8) | (c << 16) | (d << 24))

#define NVXCU_ENUM_BASE(v, id) (((v) << 20) | (id << 12))

typedef enum _nvxcu_enum_e {
    NVXCU_ENUM_INTERPOLATION  = 0x04,   
    NVXCU_ENUM_COLOR_SPACE    = 0x06,   
    NVXCU_ENUM_COLOR_RANGE    = 0x07,   
    NVXCU_ENUM_CHANNEL        = 0x09,   
    NVXCU_ENUM_CONVERT_POLICY = 0x0A,   
    NVXCU_ENUM_BORDER_MODE    = 0x0C,   
    NVXCU_ENUM_TERM_CRITERIA  = 0x0F,   
    NVXCU_ENUM_NORM_TYPE      = 0x10,   
    NVXCU_ENUM_ROUND_POLICY   = 0x12,   
} nvxcu_enum_e;

typedef enum _nvxcu_convert_policy_e {
    NVXCU_CONVERT_POLICY_WRAP = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CONVERT_POLICY) + 0x0,
    NVXCU_CONVERT_POLICY_SATURATE = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CONVERT_POLICY) + 0x1,
} nvxcu_convert_policy_e;

typedef enum _nvxcu_df_image_e {
    NVXCU_DF_IMAGE_RGB    = NVXCU_DF_IMAGE('R','G','B','2'),

    NVXCU_DF_IMAGE_RGBX   = NVXCU_DF_IMAGE('R','G','B','A'),

    NVXCU_DF_IMAGE_NV12   = NVXCU_DF_IMAGE('N','V','1','2'),

    NVXCU_DF_IMAGE_NV21   = NVXCU_DF_IMAGE('N','V','2','1'),

    NVXCU_DF_IMAGE_UYVY   = NVXCU_DF_IMAGE('U','Y','V','Y'),

    NVXCU_DF_IMAGE_YUYV   = NVXCU_DF_IMAGE('Y','U','Y','V'),

    NVXCU_DF_IMAGE_IYUV   = NVXCU_DF_IMAGE('I','Y','U','V'),

    NVXCU_DF_IMAGE_YUV4   = NVXCU_DF_IMAGE('Y','U','V','4'),

    NVXCU_DF_IMAGE_U8     = NVXCU_DF_IMAGE('U','0','0','8'),

    NVXCU_DF_IMAGE_U16    = NVXCU_DF_IMAGE('U','0','1','6'),

    NVXCU_DF_IMAGE_S16    = NVXCU_DF_IMAGE('S','0','1','6'),

    NVXCU_DF_IMAGE_U32    = NVXCU_DF_IMAGE('U','0','3','2'),

    NVXCU_DF_IMAGE_S32    = NVXCU_DF_IMAGE('S','0','3','2'),

    NVXCU_DF_IMAGE_F32    = NVXCU_DF_IMAGE('F','0','3','2'),

    NVXCU_DF_IMAGE_2F32   = NVXCU_DF_IMAGE('2','F','3','2'),

    NVXCU_DF_IMAGE_2S16   = NVXCU_DF_IMAGE('2','S','1','6'),

    NVXCU_DF_IMAGE_RGB16  = NVXCU_DF_IMAGE('S','3','1','6'),
} nvxcu_df_image_e;

typedef enum _nvxcu_channel_e {
    NVXCU_CHANNEL_0 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x0,
    NVXCU_CHANNEL_1 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x1,
    NVXCU_CHANNEL_2 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x2,
    NVXCU_CHANNEL_3 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x3,

    NVXCU_CHANNEL_R = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x10,
    NVXCU_CHANNEL_G = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x11,
    NVXCU_CHANNEL_B = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x12,
    NVXCU_CHANNEL_A = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x13,
    NVXCU_CHANNEL_Y = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x14,
    NVXCU_CHANNEL_U = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x15,
    NVXCU_CHANNEL_V = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_CHANNEL) + 0x16,
} nvxcu_channel_e;

typedef enum _nvxcu_interpolation_type_e {
    NVXCU_INTERPOLATION_TYPE_NEAREST_NEIGHBOR = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_INTERPOLATION) + 0x0,
    NVXCU_INTERPOLATION_TYPE_BILINEAR = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_INTERPOLATION) + 0x1,
    NVXCU_INTERPOLATION_TYPE_AREA = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_INTERPOLATION) + 0x2,
} nvxcu_interpolation_type_e;

typedef enum _nvxcu_color_space_e {
    NVXCU_COLOR_SPACE_NONE = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_SPACE) + 0x0,
    NVXCU_COLOR_SPACE_BT601_525 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_SPACE) + 0x1,
    NVXCU_COLOR_SPACE_BT601_625 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_SPACE) + 0x2,
    NVXCU_COLOR_SPACE_BT709 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_SPACE) + 0x3,
    NVXCU_COLOR_SPACE_DEFAULT = NVXCU_COLOR_SPACE_BT709,
} nvxcu_color_space_e;

typedef enum _nvxcu_channel_range_e {
    NVXCU_CHANNEL_RANGE_FULL = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_RANGE) + 0x0,
    NVXCU_CHANNEL_RANGE_RESTRICTED = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_COLOR_RANGE) + 0x1,
} nvxcu_channel_range_e;

typedef enum _nvxcu_border_mode_e {
    NVXCU_BORDER_MODE_UNDEFINED = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_BORDER_MODE) + 0x0,
    NVXCU_BORDER_MODE_CONSTANT = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_BORDER_MODE) + 0x1,
    NVXCU_BORDER_MODE_REPLICATE = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_BORDER_MODE) + 0x2,
} nvxcu_border_mode_e;

typedef enum _nvxcu_termination_criteria_e {
    NVXCU_TERM_CRITERIA_ITERATIONS = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_TERM_CRITERIA) + 0x0,
    NVXCU_TERM_CRITERIA_EPSILON = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_TERM_CRITERIA) + 0x1,
    NVXCU_TERM_CRITERIA_BOTH = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_TERM_CRITERIA) + 0x2,
} nvxcu_termination_criteria_e;

typedef enum _nvxcu_norm_type_e {
    NVXCU_NORM_L1 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_NORM_TYPE) + 0x0,
    NVXCU_NORM_L2 = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_NORM_TYPE) + 0x1,
} nvxcu_norm_type_e;

typedef enum _nvxcu_round_policy_e {
    NVXCU_ROUND_POLICY_TO_ZERO = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_ROUND_POLICY) + 0x1,
    NVXCU_ROUND_POLICY_TO_NEAREST_EVEN = NVXCU_ENUM_BASE(0x000, NVXCU_ENUM_ROUND_POLICY) + 0x2,
} nvxcu_round_policy_e;

typedef enum _nvxcu_flip_mode_e {
    NVXCU_FLIP_HORIZONTAL,  
    NVXCU_FLIP_VERTICAL,    
    NVXCU_FLIP_BOTH         
} nvxcu_flip_mode_e;

typedef enum _nvxcu_scanline_e {
    NVXCU_SCANLINE_LEFT_RIGHT            = 1 << 0,  
    NVXCU_SCANLINE_TOP_LEFT_BOTTOM_RIGHT = 1 << 1,  
    NVXCU_SCANLINE_TOP_BOTTOM            = 1 << 2,  
    NVXCU_SCANLINE_TOP_RIGHT_BOTTOM_LEFT = 1 << 3,  
    NVXCU_SCANLINE_RIGHT_LEFT            = 1 << 4,  
    NVXCU_SCANLINE_BOTTOM_RIGHT_TOP_LEFT = 1 << 5,  
    NVXCU_SCANLINE_BOTTOM_TOP            = 1 << 6,  
    NVXCU_SCANLINE_BOTTOM_LEFT_TOP_RIGHT = 1 << 7,  
    NVXCU_SCANLINE_CROSS                 = NVXCU_SCANLINE_LEFT_RIGHT |
                                           NVXCU_SCANLINE_RIGHT_LEFT |
                                           NVXCU_SCANLINE_TOP_BOTTOM |
                                           NVXCU_SCANLINE_BOTTOM_TOP,

    NVXCU_SCANLINE_ALL                   = 0xFF     
} nvxcu_scanline_e;

typedef enum _nvxcu_sgm_flags_e {
    NVXCU_SGM_FILTER_TOP_AREA            = 1 << 0   
} nvxcu_sgm_flags_e;

#define NVXCU_SCALE_PYRAMID_HALF    (0.5f)

#define NVXCU_SCALE_PYRAMID_ORB     (0.8408964f)

typedef union _nvxcu_pixel_value_t {
    uint8_t     RGB[3];         
    uint16_t    RGB16[3];       
    uint8_t     RGBX[4];        
    uint8_t     YUV[3];         
    uint8_t     U8;             
    uint16_t    U16;            
    int16_t     S16;            
    int16_t     S16n[4];        
    uint32_t    U32;            
    int32_t     S32;            
    float       F32;            
    float       F32n[4];        
    uint8_t     reserved[16];   
} nvxcu_pixel_value_t;

typedef struct _nvxcu_border_t {
    nvxcu_border_mode_e mode;               
    nvxcu_pixel_value_t constant_value;     
} nvxcu_border_t;

typedef struct _nvxcu_keypoint_t {
    int32_t x;                  
    int32_t y;                  
    float strength;             
    float scale;                
    float orientation;          
    int32_t tracking_status;    
    float error;                
} nvxcu_keypoint_t;

typedef struct _nvxcu_keypointf_t {
    float x;                    
    float y;                    
    float strength;             
    float scale;                
    float orientation;          
    int32_t tracking_status;    
    float error;                
} nvxcu_keypointf_t;

typedef struct _nvxcu_rectangle_t {
    uint32_t start_x;   
    uint32_t start_y;   
    uint32_t end_x;     
    uint32_t end_y;     
} nvxcu_rectangle_t;

typedef struct _nvxcu_coordinates2d_t {
    uint32_t x; 
    uint32_t y; 
} nvxcu_coordinates2d_t;

typedef struct _nvxcu_coordinates3d_t {
    uint32_t x; 
    uint32_t y; 
    uint32_t z; 
} nvxcu_coordinates3d_t;

typedef struct _nvxcu_point2f_t {
    float x;    
    float y;    
} nvxcu_point2f_t;

typedef struct _nvxcu_point3f_t {
    float x;    
    float y;    
    float z;    
} nvxcu_point3f_t;

typedef struct _nvxcu_point4f_t {
    float x;    
    float y;    
    float z;    
    float w;    
} nvxcu_point4f_t;

//----------------------------------------------------------------------------
// Temporary buffer wrapper
//----------------------------------------------------------------------------

typedef struct _nvxcu_tmp_buf_size_t {
    size_t dev_buf_size;    
    size_t host_buf_size;   
} nvxcu_tmp_buf_size_t;

typedef struct _nvxcu_tmp_buf_t {
    void *dev_ptr;      
    void *host_ptr;     
} nvxcu_tmp_buf_t;

//----------------------------------------------------------------------------
// Image wrapper
//----------------------------------------------------------------------------

#define NVXCU_NB_MAX_PLANES     (4u)

typedef enum _nvxcu_image_type_e {
    NVXCU_PITCH_LINEAR_IMAGE,   
    NVXCU_UNIFORM_IMAGE         
} nvxcu_image_type_e;

typedef struct _nvxcu_image_t {
    nvxcu_image_type_e image_type;  
    nvxcu_df_image_e format;        
    uint32_t width;                 
    uint32_t height;                
} nvxcu_image_t;

typedef struct _nvxcu_pitch_linear_image_t {
    nvxcu_image_t base;             
    struct {
        void *dev_ptr;              
        int32_t pitch_in_bytes;     
    } planes[NVXCU_NB_MAX_PLANES];  
} nvxcu_pitch_linear_image_t;

typedef struct _nvxcu_uniform_image_t {
    nvxcu_image_t base;                 
    nvxcu_pixel_value_t uniform_value;  
} nvxcu_uniform_image_t;

//----------------------------------------------------------------------------
// Array wrapper
//----------------------------------------------------------------------------

typedef enum _nvxcu_array_type_e {
    NVXCU_PLAIN_ARRAY,  
} nvxcu_array_type_e;

typedef struct _nvxcu_array_t {
    nvxcu_array_type_e array_type;      
    nvxcu_array_item_type_e item_type;  
    uint32_t capacity;                  
} nvxcu_array_t;

typedef struct _nvxcu_plain_array_t {
    nvxcu_array_t base;             
    void *dev_ptr;                  
    uint32_t *num_items_dev_ptr;    
} nvxcu_plain_array_t;

//----------------------------------------------------------------------------
// Pyramid wrapper
//----------------------------------------------------------------------------

typedef enum _nvxcu_pyramid_type_e {
    NVXCU_PITCH_LINEAR_PYRAMID,     
} nvxcu_pyramid_type_e;

typedef struct _nvxcu_pyramid_t {
    nvxcu_pyramid_type_e pyramid_type;  
    uint32_t num_levels;                
    float scale;                        
} nvxcu_pyramid_t;

typedef struct _nvxcu_pitch_linear_pyramid_t {
    nvxcu_pyramid_t base;                   
    nvxcu_pitch_linear_image_t *levels;     
} nvxcu_pitch_linear_pyramid_t;

//----------------------------------------------------------------------------
// Execution target
//----------------------------------------------------------------------------

typedef enum _nvxcu_exec_target_type_e {
    NVXCU_STREAM_EXEC_TARGET,   
} nvxcu_exec_target_type_e;

typedef struct _nvxcu_exec_target_t {
    nvxcu_exec_target_type_e exec_target_type;  
} nvxcu_exec_target_t;

typedef struct _nvxcu_stream_exec_target_t {
    nvxcu_exec_target_t base;           
    cudaStream_t stream;                
    struct cudaDeviceProp dev_prop;     
} nvxcu_stream_exec_target_t;

//----------------------------------------------------------------------------
// ChannelExtract
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuChannelExtract(const nvxcu_image_t* input,
                                                   nvxcu_channel_e channel,
                                                   const nvxcu_image_t* output,
                                                   const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// ChannelCombine
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuChannelCombine(const nvxcu_image_t* plane0,
                                                   const nvxcu_image_t* plane1,
                                                   const nvxcu_image_t* plane2,
                                                   const nvxcu_image_t* plane3,
                                                   const nvxcu_image_t* output,
                                                   const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// AbsDiff
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuAbsDiff(const nvxcu_image_t* in1,
                                            const nvxcu_image_t* in2,
                                            const nvxcu_image_t* out,
                                            const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Phase
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuPhase(const nvxcu_image_t* grad_x,
                                          const nvxcu_image_t* grad_y,
                                          const nvxcu_image_t* orientation,
                                          const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Magnitude
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuMagnitude(const nvxcu_image_t* grad_x,
                                              const nvxcu_image_t* grad_y,
                                              const nvxcu_image_t* mag,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Threshold
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuThresholdBinary(const nvxcu_image_t* input,
                                                    nvxcu_pixel_value_t thresh_value,
                                                    nvxcu_pixel_value_t true_value,
                                                    nvxcu_pixel_value_t false_value,
                                                    const nvxcu_image_t* output,
                                                    const nvxcu_exec_target_t* exec_target);

NVX_C_API nvxcu_error_status_e nvxcuThresholdRange(const nvxcu_image_t* input,
                                                   nvxcu_pixel_value_t thresh_lower_value,
                                                   nvxcu_pixel_value_t thresh_upper_value,
                                                   nvxcu_pixel_value_t true_value,
                                                   nvxcu_pixel_value_t false_value,
                                                   const nvxcu_image_t* output,
                                                   const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// AccumulateImage
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuAccumulateImage(const nvxcu_image_t* input,
                                                    const nvxcu_image_t* accum,
                                                    const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// AccumulateWeighted
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuAccumulateWeighted(const nvxcu_image_t* input,
                                                       float alpha,
                                                       const nvxcu_image_t* accum,
                                                       const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// AccumulateSquare
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuAccumulateSquare(const nvxcu_image_t* input,
                                                     uint32_t shift,
                                                     const nvxcu_image_t* accum,
                                                     const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// And
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuBitwiseAnd(const nvxcu_image_t* in1,
                                               const nvxcu_image_t* in2,
                                               const nvxcu_image_t* out,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Or
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuBitwiseOr(const nvxcu_image_t* in1,
                                              const nvxcu_image_t* in2,
                                              const nvxcu_image_t* out,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Xor
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuBitwiseXor(const nvxcu_image_t* in1,
                                               const nvxcu_image_t* in2,
                                               const nvxcu_image_t* out,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Not
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuBitwiseNot(const nvxcu_image_t* input,
                                               const nvxcu_image_t* output,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Add
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuAdd(const nvxcu_image_t* in1,
                                        const nvxcu_image_t* in2,
                                        nvxcu_convert_policy_e policy,
                                        const nvxcu_image_t* out,
                                        const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Subtract
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuSubtract(const nvxcu_image_t* in1,
                                             const nvxcu_image_t* in2,
                                             nvxcu_convert_policy_e policy,
                                             const nvxcu_image_t* out,
                                             const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Subtract
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuMultiply(const nvxcu_image_t* in1,
                                             const nvxcu_image_t* in2,
                                             float scale,
                                             nvxcu_convert_policy_e overflow_policy,
                                             nvxcu_round_policy_e rounding_policy,
                                             const nvxcu_image_t* out,
                                             const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// ConvertDepth
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuConvertDepth(const nvxcu_image_t* input,
                                                 const nvxcu_image_t* output,
                                                 nvxcu_convert_policy_e policy,
                                                 int32_t shift,
                                                 const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// ColorConvert
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuColorConvert(const nvxcu_image_t* input,
                                                 const nvxcu_image_t* output,
                                                 nvxcu_color_space_e color_space,
                                                 nvxcu_channel_range_e channel_range,
                                                 const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// TableLookup
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuTableLookup(const nvxcu_image_t* input,
                                                const uint8_t* lut_dev_ptr,
                                                uint32_t lut_count,
                                                const nvxcu_image_t* output,
                                                const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Sobel3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuSobel3x3(const nvxcu_image_t* input,
                                             const nvxcu_image_t* output_x,
                                             const nvxcu_image_t* output_y,
                                             const nvxcu_border_t* border,
                                             const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Erode3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuErode3x3(const nvxcu_image_t* input,
                                             const nvxcu_image_t* output,
                                             const nvxcu_border_t* border,
                                             const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Dilate3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuDilate3x3(const nvxcu_image_t* input,
                                              const nvxcu_image_t* output,
                                              const nvxcu_border_t* border,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Median3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuMedian3x3(const nvxcu_image_t* input,
                                              const nvxcu_image_t* output,
                                              const nvxcu_border_t* border,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Box3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuBox3x3(const nvxcu_image_t* input,
                                           const nvxcu_image_t* output,
                                           const nvxcu_border_t* border,
                                           const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Gaussian3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuGaussian3x3(const nvxcu_image_t* input,
                                                const nvxcu_image_t* output,
                                                const nvxcu_border_t* border,
                                                const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Scharr3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuScharr3x3(const nvxcu_image_t* input,
                                              const nvxcu_image_t* output_x, // optional
                                              const nvxcu_image_t* output_y, // optional
                                              const nvxcu_border_t* border,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Laplacian3x3
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuLaplacian3x3(const nvxcu_image_t* input,
                                                 const nvxcu_image_t* output,
                                                 const nvxcu_border_t* border,
                                                 const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// IntegralImage
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuIntegralImage(const nvxcu_image_t* input,
                                                  const nvxcu_image_t* output,
                                                  const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Histogram
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHistogram_GetBufSize(uint32_t input_width, uint32_t input_height,
                                                         nvxcu_df_image_e input_format,
                                                         uint32_t offset,
                                                         uint32_t range,
                                                         uint32_t num_bins,
                                                         uint32_t window_size,
                                                         const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHistogram(const nvxcu_image_t* input,
                                              uint32_t *distribution_dev_ptr,
                                              uint32_t offset,
                                              uint32_t range,
                                              uint32_t num_bins,
                                              uint32_t window_size,
                                              const nvxcu_tmp_buf_t* tmp_buf,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// EqualizeHist
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuEqualizeHist_GetBufSize(uint32_t input_width, uint32_t input_height,
                                                            nvxcu_df_image_e input_format,
                                                            const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuEqualizeHist(const nvxcu_image_t* input,
                                                 const nvxcu_image_t* output,
                                                 const nvxcu_tmp_buf_t* tmp_buf,
                                                 const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// ScaleImage
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuScaleImage(const nvxcu_image_t* src,
                                               const nvxcu_image_t* dst,
                                               nvxcu_interpolation_type_e type,
                                               const nvxcu_border_t* border,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// WarpAffine
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuWarpAffine(const nvxcu_image_t* input,
                                               const float *matrix_dev_ptr,
                                               nvxcu_interpolation_type_e type,
                                               const nvxcu_image_t* output,
                                               const nvxcu_border_t* border,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// WarpPerspective
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuWarpPerspective(const nvxcu_image_t* input,
                                                    const float *matrix_dev_ptr,
                                                    nvxcu_interpolation_type_e type,
                                                    const nvxcu_image_t* output,
                                                    const nvxcu_border_t* border,
                                                    const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Remap
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuRemap(const nvxcu_image_t* input,
                                          const nvxcu_image_t* table,
                                          nvxcu_interpolation_type_e policy,
                                          const nvxcu_image_t* output,
                                          const nvxcu_border_t* border,
                                          const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// MeanStdDev
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuMeanStdDev_GetBufSize(uint32_t input_width, uint32_t input_height,
                                                          nvxcu_df_image_e input_format,
                                                          const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuMeanStdDev(const nvxcu_image_t* input,
                                               float *mean_dev_ptr,
                                               float *stddev_dev_ptr,
                                               const nvxcu_tmp_buf_t* tmp_buf,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// MinMaxLoc
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuMinMaxLoc_GetBufSize(uint32_t input_width, uint32_t input_height,
                                                         nvxcu_df_image_e input_format,
                                                         const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuMinMaxLoc(const nvxcu_image_t* input,
                                              void *min_val_dev_ptr,
                                              void *max_val_dev_ptr,
                                              const nvxcu_array_t* min_loc,
                                              const nvxcu_array_t* max_loc,
                                              uint32_t *min_count_dev_ptr,
                                              uint32_t *max_count_dev_ptr,
                                              const nvxcu_tmp_buf_t* tmp_buf,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// Convolve
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuConvolve_GetBufSize(uint32_t width, uint32_t height,
                                                        nvxcu_df_image_e input_format,
                                                        int32_t kernel_width, int32_t kernel_height,
                                                        nvxcu_df_image_e output_format,
                                                        const nvxcu_border_t* border,
                                                        const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuConvolve(const nvxcu_image_t* input,
                                             const int16_t *kernel_dev_ptr,
                                             uint32_t kernel_div,
                                             int32_t kernel_width, int32_t kernel_height,
                                             const nvxcu_image_t* output,
                                             const nvxcu_border_t* border,
                                             const nvxcu_tmp_buf_t* tmp_buf,
                                             const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HalfScaleGaussian
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuHalfScaleGaussian(const nvxcu_image_t* input,
                                                      const nvxcu_image_t* output,
                                                      int32_t kernel_size,
                                                      const nvxcu_border_t* border,
                                                      const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// GaussianPyramid
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuGaussianPyramid_GetBufSize(uint32_t width, uint32_t height,
                                                               uint32_t num_levels,
                                                               float scale,
                                                               const nvxcu_border_t* border,
                                                               const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuGaussianPyramid(const nvxcu_pyramid_t* pyr,
                                                    const nvxcu_tmp_buf_t* tmp_buf,
                                                    const nvxcu_border_t* border,
                                                    const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// CannyEdgeDetector
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuCannyEdgeDetector_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                                 int32_t gradient_size,
                                                                 const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuCannyEdgeDetector(const nvxcu_image_t* input,
                                                      int32_t lower_thresh, int32_t upper_thresh,
                                                      int32_t gradient_size,
                                                      nvxcu_norm_type_e norm_type,
                                                      const nvxcu_image_t* output,
                                                      const nvxcu_tmp_buf_t* tmp_buf,
                                                      const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HarrisCorners
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHarrisCorners_GetBufSize(uint32_t width, uint32_t height,
                                                             nvxcu_df_image_e format,
                                                             float min_distance,
                                                             int32_t gradient_size,
                                                             int32_t block_size,
                                                             nvxcu_array_item_type_e arr_type, uint32_t arr_capacity,
                                                             const nvxcu_border_t* border,
                                                             const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHarrisCorners(const nvxcu_image_t* input,
                                                  float strength_thresh,
                                                  float min_distance,
                                                  float sensitivity,
                                                  int32_t gradient_size,
                                                  int32_t block_size,
                                                  const nvxcu_array_t* corners,
                                                  uint32_t *num_corners_dev_ptr,
                                                  const nvxcu_tmp_buf_t* tmp_buf,
                                                  const nvxcu_border_t* border,
                                                  const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// FastCorners
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuFastCorners_GetBufSize(uint32_t width, uint32_t height,
                                                           nvxcu_df_image_e format,
                                                           int32_t nonmax_suppression,
                                                           nvxcu_array_item_type_e arr_type, uint32_t arr_capacity,
                                                           const nvxcu_border_t* border,
                                                           const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuFastCorners(const nvxcu_image_t* input,
                                                float strength_thresh,
                                                int32_t nonmax_suppression,
                                                const nvxcu_array_t* corners,
                                                uint32_t *num_corners_dev_ptr,
                                                const nvxcu_tmp_buf_t* tmp_buf,
                                                const nvxcu_border_t* border,
                                                const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// OpticalFlowPyrLK
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuOpticalFlowPyrLK_GetBufSize(uint32_t width, uint32_t height, uint32_t levels, float scale,
                                                                nvxcu_array_item_type_e arr_type, uint32_t capacity,
                                                                uint32_t window_dimension,
                                                                int32_t calcError,
                                                                const nvxcu_border_t* border,
                                                                const struct cudaDeviceProp* prop);
NVX_C_API nvxcu_error_status_e nvxcuOpticalFlowPyrLK(const nvxcu_pyramid_t* old_images,
                                                     const nvxcu_pyramid_t* new_images,
                                                     const nvxcu_array_t* old_points,
                                                     const nvxcu_array_t* new_points,
                                                     nvxcu_termination_criteria_e termination,
                                                     float epsilon,
                                                     uint32_t num_iterations,
                                                     uint32_t window_dimension,
                                                     int32_t calcError,
                                                     const nvxcu_tmp_buf_t* tmp_buf,
                                                     const nvxcu_border_t* border,
                                                     const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// FlipImage
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuFlipImage(const nvxcu_image_t* input,
                                              const nvxcu_image_t* output,
                                              nvxcu_flip_mode_e flip_mode,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HarrisTrack
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHarrisTrack_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                           nvxcu_array_item_type_e arr_type, uint32_t arr_capacity,
                                                           uint32_t cell_size,
                                                           const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHarrisTrack(const nvxcu_image_t* input,
                                                const nvxcu_array_t* output,
                                                const nvxcu_image_t* mask,
                                                const nvxcu_array_t* tracked_points,
                                                float k, float threshold, uint32_t cell_size,
                                                size_t *num_corners_dev_ptr,
                                                const nvxcu_tmp_buf_t* tmp_buf,
                                                const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// FastTrack
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuFastTrack_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                         nvxcu_array_item_type_e arr_type, uint32_t arr_capacity,
                                                         uint32_t cell_size,
                                                         const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuFastTrack(const nvxcu_image_t* input,
                                              const nvxcu_array_t* output,
                                              const nvxcu_image_t* mask,
                                              const nvxcu_array_t* tracked_points,
                                              uint32_t type, uint32_t threshold, uint32_t cell_size,
                                              size_t *num_corners_dev_ptr,
                                              const nvxcu_tmp_buf_t* tmp_buf,
                                              const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// MultiplyByScalar
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuMultiplyByScalar(const nvxcu_image_t* src,
                                                     const nvxcu_image_t* dst,
                                                     float alpha,
                                                     const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// CreateMotionField
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuCreateMotionField(const nvxcu_image_t* ref_image,
                                                      const nvxcu_image_t* cur_image,
                                                      const nvxcu_image_t* anchor, // optional
                                                      const nvxcu_image_t* bias, // optional
                                                      const nvxcu_image_t* best_mv0, // optional
                                                      const nvxcu_image_t* best_mv1, // optional
                                                      const nvxcu_image_t* sad_table, // optional
                                                      int32_t block_size,
                                                      int32_t search_window_width, int32_t search_window_height,
                                                      float bias_weight,
                                                      int32_t mv_div_factor,
                                                      const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// RefineMotionField
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuRefineMotionField_GetBufSize(uint32_t mv_width, uint32_t mv_height,
                                                                 int32_t search_window_width, int32_t search_window_height,
                                                                 const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuRefineMotionField(const nvxcu_image_t* in_mv0,
                                                      const nvxcu_image_t* in_mv1,
                                                      const nvxcu_image_t* sad_table,
                                                      const nvxcu_image_t* out_mv0,
                                                      const nvxcu_image_t* out_mv1, // optional
                                                      int32_t search_window_width, int32_t search_window_height,
                                                      int32_t num_iterations,
                                                      float smoothness_factor,
                                                      int32_t mv_div_factor,
                                                      const nvxcu_tmp_buf_t* tmp_buf,
                                                      const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// PartitionMotionField
//----------------------------------------------------------------------------

NVX_C_API nvxcu_error_status_e nvxcuPartitionMotionField(const nvxcu_image_t* ref_image,
                                                         const nvxcu_image_t* cur_image,
                                                         const nvxcu_image_t* in_mv_0,
                                                         const nvxcu_image_t* in_mv_1,
                                                         const nvxcu_image_t* out_mv_0,
                                                         const nvxcu_image_t* out_mv_1, // optional
                                                         float smoothness_factor,
                                                         int32_t mv_div_factor,
                                                         const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// StereoBlockMatching
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuStereoBlockMatching_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                                   uint32_t win_size,
                                                                   uint32_t max_disparity,
                                                                   const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuStereoBlockMatching(const nvxcu_image_t* left,
                                                        const nvxcu_image_t* right,
                                                        const nvxcu_image_t* disp,
                                                        uint32_t win_size,
                                                        uint32_t max_disparity,
                                                        const nvxcu_tmp_buf_t* tmp_buf,
                                                        const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// SemiGlobalMatching
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuSemiGlobalMatching_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                                  int32_t minD, int32_t maxD,
                                                                  int32_t sad, nvxcu_sgm_flags_e flags,
                                                                  const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuSemiGlobalMatching(const nvxcu_image_t* left,
                                                       const nvxcu_image_t* right,
                                                       const nvxcu_image_t* disparity,
                                                       int32_t minD,
                                                       int32_t maxD,
                                                       int32_t P1,
                                                       int32_t P2,
                                                       int32_t sad,
                                                       int32_t clip,
                                                       int32_t max_diff,
                                                       int32_t uniqueness,
                                                       nvxcu_scanline_e scanlines_mask,
                                                       nvxcu_sgm_flags_e flags,
                                                       const nvxcu_tmp_buf_t* tmp_buf,
                                                       const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HoughLines
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHoughLines_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                          uint32_t arr_capacity,
                                                          float rho, float theta,
                                                          const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHoughLines(const nvxcu_image_t* input,
                                               const nvxcu_array_t* output,
                                               float rho, float theta, uint32_t threshold,
                                               uint32_t *num_lines_dev_ptr,
                                               const nvxcu_tmp_buf_t* tmp_buf,
                                               const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HoughSegments
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHoughSegments_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                             uint32_t arr_capacity,
                                                             float rho, float theta,
                                                             uint32_t min_line_length, uint32_t max_line_gap,
                                                             const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHoughSegments(const nvxcu_image_t* input,
                                                  const nvxcu_array_t* output,
                                                  float rho, float theta, uint32_t threshold,
                                                  uint32_t min_line_length, uint32_t max_line_gap,
                                                  uint32_t *num_segments_dev_ptr,
                                                  const nvxcu_tmp_buf_t* tmp_buf,
                                                  const nvxcu_exec_target_t* exec_target);

//----------------------------------------------------------------------------
// HoughCircles
//----------------------------------------------------------------------------

NVX_C_API nvxcu_tmp_buf_size_t nvxcuHoughCircles_GetBufSize(uint32_t width, uint32_t height, nvxcu_df_image_e format,
                                                            uint32_t arr_capacity,
                                                            float dp, float min_dist,
                                                            uint32_t min_radius, uint32_t max_radius,
                                                            const struct cudaDeviceProp* prop);

NVX_C_API nvxcu_error_status_e nvxcuHoughCircles(const nvxcu_image_t* edges,
                                                 const nvxcu_image_t* dx,
                                                 const nvxcu_image_t* dy,
                                                 const nvxcu_array_t* circles,
                                                 uint32_t *num_detections_dev_ptr,
                                                 float dp,
                                                 float min_dist,
                                                 uint32_t min_radius, uint32_t max_radius,
                                                 uint32_t acc_threshold,
                                                 const nvxcu_tmp_buf_t* tmp_buf,
                                                 const nvxcu_exec_target_t* exec_target);

#endif