pvcam.h

Go to the documentation of this file.

/******************************************************************************/
/* Copyright (C) Teledyne Photometrics. All rights reserved.                  */
/******************************************************************************/

#ifndef _PVCAM_H
#define _PVCAM_H

/******************************************************************************/
/* Constants                                                                  */
/******************************************************************************/

#define MAX_CAM                16

/******************************************************************************/
/* Name/ID sizes                                                              */
/******************************************************************************/

#define CAM_NAME_LEN                32

#define PARAM_NAME_LEN              32

#define ERROR_MSG_LEN               255

#define CCD_NAME_LEN                17

#define MAX_ALPHA_SER_NUM_LEN       32

#define MAX_PP_NAME_LEN             32

#define MAX_SYSTEM_NAME_LEN         32

#define MAX_VENDOR_NAME_LEN         32

#define MAX_PRODUCT_NAME_LEN        32

#define MAX_CAM_PART_NUM_LEN        32

#define MAX_GAIN_NAME_LEN           32

#define MAX_SPDTAB_NAME_LEN         32

#define MAX_CAM_SYSTEMS_INFO_LEN    1024

/******************************************************************************/
/* Data types                                                                 */
/******************************************************************************/

typedef struct _TAG_PVCAM_FRAME_INFO_GUID
{
    uns32 f1;
    uns16 f2;
    uns16 f3;
    uns8  f4[8];
}
PVCAM_FRAME_INFO_GUID;

typedef struct _TAG_FRAME_INFO
{
    PVCAM_FRAME_INFO_GUID FrameInfoGUID;
    int16 hCam;           
    int32 FrameNr;        
    long64 TimeStamp;     
    int32 ReadoutTime;    
    long64 TimeStampBOF;  
}
FRAME_INFO;

typedef enum PL_OPEN_MODES
{
    OPEN_EXCLUSIVE
}
PL_OPEN_MODES;

typedef enum PL_COOL_MODES
{
    NORMAL_COOL,
    CRYO_COOL,
    NO_COOL
}
PL_COOL_MODES;

typedef enum PL_MPP_MODES
{
    MPP_UNKNOWN,
    MPP_ALWAYS_OFF,
    MPP_ALWAYS_ON,
    MPP_SELECTABLE
}
PL_MPP_MODES;

typedef enum PL_SHTR_MODES
{
    SHTR_FAULT,
    SHTR_OPENING,
    SHTR_OPEN,
    SHTR_CLOSING,
    SHTR_CLOSED,
    SHTR_UNKNOWN
}
PL_SHTR_MODES;

typedef enum PL_PMODES
{
    PMODE_NORMAL,
    PMODE_FT,
    PMODE_MPP,
    PMODE_FT_MPP,
    PMODE_ALT_NORMAL,
    PMODE_ALT_FT,
    PMODE_ALT_MPP,
    PMODE_ALT_FT_MPP
}
PL_PMODES;

typedef enum PL_COLOR_MODES
{
    COLOR_NONE     = 0, 
    COLOR_RESERVED = 1, 
    COLOR_RGGB     = 2, 
    COLOR_GRBG,         
    COLOR_GBRG,         
    COLOR_BGGR          
}
PL_COLOR_MODES;

typedef enum PL_IMAGE_FORMATS
{
    PL_IMAGE_FORMAT_MONO16 = 0, 
    PL_IMAGE_FORMAT_BAYER16,    
    PL_IMAGE_FORMAT_MONO8,      
    PL_IMAGE_FORMAT_BAYER8,     
    PL_IMAGE_FORMAT_MONO24,     
    PL_IMAGE_FORMAT_BAYER24,    
    PL_IMAGE_FORMAT_RGB24,      
    PL_IMAGE_FORMAT_RGB48,      
    PL_IMAGE_FORMAT_RGB72,      
    PL_IMAGE_FORMAT_MONO32,     
    PL_IMAGE_FORMAT_BAYER32     
}
PL_IMAGE_FORMATS;

typedef enum PL_IMAGE_COMPRESSIONS
{
    PL_IMAGE_COMPRESSION_NONE = 0,     
    /* Bit-packing compression modes */
    PL_IMAGE_COMPRESSION_RESERVED8 = 8,
    PL_IMAGE_COMPRESSION_BITPACK9,        
    PL_IMAGE_COMPRESSION_BITPACK10,       
    PL_IMAGE_COMPRESSION_BITPACK11,       
    PL_IMAGE_COMPRESSION_BITPACK12,       
    PL_IMAGE_COMPRESSION_BITPACK13,       
    PL_IMAGE_COMPRESSION_BITPACK14,       
    PL_IMAGE_COMPRESSION_BITPACK15,       
    PL_IMAGE_COMPRESSION_RESERVED16 = 16,
    PL_IMAGE_COMPRESSION_BITPACK17,       
    PL_IMAGE_COMPRESSION_BITPACK18,       
    PL_IMAGE_COMPRESSION_RESERVED24 = 24,
    PL_IMAGE_COMPRESSION_RESERVED32 = 32,
    /* Other compression modes below */
}
PL_IMAGE_COMPRESSIONS;

typedef enum PL_FRAME_ROTATE_MODES
{
    PL_FRAME_ROTATE_MODE_NONE = 0, 
    PL_FRAME_ROTATE_MODE_90CW,     
    PL_FRAME_ROTATE_MODE_180CW,    
    PL_FRAME_ROTATE_MODE_270CW     
}
PL_FRAME_ROTATE_MODES;

typedef enum PL_FRAME_FLIP_MODES
{
    PL_FRAME_FLIP_MODE_NONE = 0, 
    PL_FRAME_FLIP_MODE_X,        
    PL_FRAME_FLIP_MODE_Y,        
    PL_FRAME_FLIP_MODE_XY        
}
PL_FRAME_FLIP_MODES;

typedef enum PL_PARAM_ATTRIBUTES
{
    ATTR_CURRENT,
    ATTR_COUNT,
    ATTR_TYPE,
    ATTR_MIN,
    ATTR_MAX,
    ATTR_DEFAULT,
    ATTR_INCREMENT,
    ATTR_ACCESS,
    ATTR_AVAIL
}
PL_PARAM_ATTRIBUTES;

typedef enum PL_PARAM_ACCESS
{
    ACC_READ_ONLY = 1,
    ACC_READ_WRITE,
    ACC_EXIST_CHECK_ONLY,
    ACC_WRITE_ONLY
}
PL_PARAM_ACCESS;

typedef enum PL_IO_TYPE
{
    IO_TYPE_TTL, 
    IO_TYPE_DAC 
}
PL_IO_TYPE;

typedef enum PL_IO_DIRECTION
{
    IO_DIR_INPUT,           
    IO_DIR_OUTPUT,          
    IO_DIR_INPUT_OUTPUT     
}
PL_IO_DIRECTION;

typedef enum PL_READOUT_PORTS
{
    READOUT_PORT_0 = 0,
    READOUT_PORT_1,
    READOUT_PORT_2,
    READOUT_PORT_3
}
PL_READOUT_PORTS;

typedef enum PL_CLEAR_MODES
{
    CLEAR_NEVER,
    CLEAR_AUTO = CLEAR_NEVER,
    CLEAR_PRE_EXPOSURE,
    CLEAR_PRE_SEQUENCE,
    CLEAR_POST_SEQUENCE,
    CLEAR_PRE_POST_SEQUENCE,
    CLEAR_PRE_EXPOSURE_POST_SEQ,

    /* Should be the last and never used value. */
    MAX_CLEAR_MODE
}
PL_CLEAR_MODES;

typedef enum PL_SHTR_OPEN_MODES
{
    OPEN_NEVER,
    OPEN_PRE_EXPOSURE,
    OPEN_PRE_SEQUENCE,
    OPEN_PRE_TRIGGER,
    OPEN_NO_CHANGE
}
PL_SHTR_OPEN_MODES;

typedef enum PL_EXPOSURE_MODES
{
    TIMED_MODE,
    STROBED_MODE,
    BULB_MODE,
    TRIGGER_FIRST_MODE,
    FLASH_MODE,
    VARIABLE_TIMED_MODE,
    INT_STROBE_MODE,
    MAX_EXPOSE_MODE = 7,

    /*
    Extended EXPOSURE modes used with #PARAM_EXPOSURE_MODE when
    camera dynamically reports its capabilities.
    The "7" in each of these calculations comes from the previous
    definition of #MAX_EXPOSE_MODE when this file was defined.
    */

    EXT_TRIG_INTERNAL = (7 + 0) << 8,
    EXT_TRIG_TRIG_FIRST = (7 + 1) << 8,
    EXT_TRIG_EDGE_RISING = (7 + 2) << 8,
    EXT_TRIG_LEVEL = (7 + 3) << 8,
    EXT_TRIG_SOFTWARE_FIRST = (7 + 4) << 8,
    EXT_TRIG_SOFTWARE_EDGE = (7 + 5) << 8,
    EXT_TRIG_LEVEL_OVERLAP = (7 + 6) << 8,
    EXT_TRIG_LEVEL_PULSED = (7 + 7) << 8
}
PL_EXPOSURE_MODES;

typedef enum PL_SW_TRIG_STATUSES
{
    PL_SW_TRIG_STATUS_TRIGGERED = 0,
    PL_SW_TRIG_STATUS_IGNORED
}
PL_SW_TRIG_STATUSES;

typedef enum PL_EXPOSE_OUT_MODES
{
    EXPOSE_OUT_FIRST_ROW = 0,
    EXPOSE_OUT_ALL_ROWS,
    EXPOSE_OUT_ANY_ROW,
    EXPOSE_OUT_ROLLING_SHUTTER,
    EXPOSE_OUT_LINE_TRIGGER,
    EXPOSE_OUT_GLOBAL_SHUTTER,

    /* Should be the last and never used value. */
    MAX_EXPOSE_OUT_MODE
}
PL_EXPOSE_OUT_MODES;

typedef enum PL_FAN_SPEEDS
{
    FAN_SPEED_HIGH,   
    FAN_SPEED_MEDIUM, 
    FAN_SPEED_LOW,    
    FAN_SPEED_OFF     
}
PL_FAN_SPEEDS;

typedef enum PL_TRIGTAB_SIGNALS
{
    PL_TRIGTAB_SIGNAL_EXPOSE_OUT 
}
PL_TRIGTAB_SIGNALS;

typedef enum PL_FRAME_DELIVERY_MODES
{
    PL_FRAME_DELIVERY_MODE_MAX_FPS = 0,
    PL_FRAME_DELIVERY_MODE_CONSTANT_INTERVALS
}
PL_FRAME_DELIVERY_MODES;

typedef enum PL_CAM_INTERFACE_TYPES
{
    PL_CAM_IFC_TYPE_UNKNOWN     = 0,        
    PL_CAM_IFC_TYPE_1394        = 0x100,    
    PL_CAM_IFC_TYPE_1394_A,                 
    PL_CAM_IFC_TYPE_1394_B,                 
    PL_CAM_IFC_TYPE_USB         = 0x200,    
    PL_CAM_IFC_TYPE_USB_1_1,                
    PL_CAM_IFC_TYPE_USB_2_0,                
    PL_CAM_IFC_TYPE_USB_3_0,                
    PL_CAM_IFC_TYPE_USB_3_1,                
    PL_CAM_IFC_TYPE_PCI         = 0x400,    
    PL_CAM_IFC_TYPE_PCI_LVDS,               
    PL_CAM_IFC_TYPE_PCIE        = 0x800,    
    PL_CAM_IFC_TYPE_PCIE_LVDS,              
    PL_CAM_IFC_TYPE_PCIE_X1,                
    PL_CAM_IFC_TYPE_PCIE_X4,                
    PL_CAM_IFC_TYPE_PCIE_X8,                
    PL_CAM_IFC_TYPE_VIRTUAL     = 0x1000,   
    PL_CAM_IFC_TYPE_ETHERNET    = 0x2000    
}
PL_CAM_INTERFACE_TYPES;

typedef enum PL_CAM_INTERFACE_MODES
{
    PL_CAM_IFC_MODE_UNSUPPORTED = 0, 
    PL_CAM_IFC_MODE_CONTROL_ONLY,    
    PL_CAM_IFC_MODE_IMAGING          
}
PL_CAM_INTERFACE_MODES;

typedef enum PL_CENTROIDS_MODES
{
    PL_CENTROIDS_MODE_LOCATE = 0, 
    PL_CENTROIDS_MODE_TRACK,      
    PL_CENTROIDS_MODE_BLOB        
}
PL_CENTROIDS_MODES;


typedef enum PL_SCAN_MODES
{
    PL_SCAN_MODE_AUTO = 0,
    PL_SCAN_MODE_PROGRAMMABLE_LINE_DELAY,
    PL_SCAN_MODE_PROGRAMMABLE_SCAN_WIDTH
}
PL_SCAN_MODES;


typedef enum PL_SCAN_DIRECTIONS
{
    PL_SCAN_DIRECTION_DOWN = 0,
    PL_SCAN_DIRECTION_UP,
    PL_SCAN_DIRECTION_DOWN_UP
}
PL_SCAN_DIRECTIONS;

typedef enum PP_FEATURE_IDS
{
    PP_FEATURE_RING_FUNCTION,
    PP_FEATURE_BIAS,
    PP_FEATURE_BERT, 
    PP_FEATURE_QUANT_VIEW,
    PP_FEATURE_BLACK_LOCK,
    PP_FEATURE_TOP_LOCK,
    PP_FEATURE_VARI_BIT,
    PP_FEATURE_RESERVED,            
    PP_FEATURE_DESPECKLE_BRIGHT_HIGH,
    PP_FEATURE_DESPECKLE_DARK_LOW,
    PP_FEATURE_DEFECTIVE_PIXEL_CORRECTION,
    PP_FEATURE_DYNAMIC_DARK_FRAME_CORRECTION,
    PP_FEATURE_HIGH_DYNAMIC_RANGE,
    PP_FEATURE_DESPECKLE_BRIGHT_LOW,
    PP_FEATURE_DENOISING, 
    PP_FEATURE_DESPECKLE_DARK_HIGH,
    PP_FEATURE_ENHANCED_DYNAMIC_RANGE,
    PP_FEATURE_FRAME_SUMMING,
    PP_FEATURE_LARGE_CLUSTER_CORRECTION,
    PP_FEATURE_MAX
}
PP_FEATURE_IDS;

#define PP_MAX_PARAMETERS_PER_FEATURE   10

typedef enum PP_PARAMETER_IDS
{
    PP_PARAMETER_RF_FUNCTION                            = (PP_FEATURE_RING_FUNCTION * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_BIAS_ENABLED                             = (PP_FEATURE_BIAS * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_BIAS_LEVEL,
    PP_FEATURE_BERT_ENABLED                             = (PP_FEATURE_BERT * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_BERT_THRESHOLD,
    PP_FEATURE_QUANT_VIEW_ENABLED                       = (PP_FEATURE_QUANT_VIEW * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_QUANT_VIEW_E,
    PP_FEATURE_BLACK_LOCK_ENABLED                       = (PP_FEATURE_BLACK_LOCK * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_BLACK_LOCK_BLACK_CLIP,
    PP_FEATURE_TOP_LOCK_ENABLED                         = (PP_FEATURE_TOP_LOCK * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_TOP_LOCK_WHITE_CLIP,
    PP_FEATURE_VARI_BIT_ENABLED                         = (PP_FEATURE_VARI_BIT * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_VARI_BIT_BIT_DEPTH,
    PP_FEATURE_DESPECKLE_BRIGHT_HIGH_ENABLED            = (PP_FEATURE_DESPECKLE_BRIGHT_HIGH * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DESPECKLE_BRIGHT_HIGH_THRESHOLD,
    PP_FEATURE_DESPECKLE_BRIGHT_HIGH_MIN_ADU_AFFECTED,
    PP_FEATURE_DESPECKLE_DARK_LOW_ENABLED               = (PP_FEATURE_DESPECKLE_DARK_LOW * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DESPECKLE_DARK_LOW_THRESHOLD,
    PP_FEATURE_DESPECKLE_DARK_LOW_MAX_ADU_AFFECTED,
    PP_FEATURE_DEFECTIVE_PIXEL_CORRECTION_ENABLED       = (PP_FEATURE_DEFECTIVE_PIXEL_CORRECTION * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DYNAMIC_DARK_FRAME_CORRECTION_ENABLED    = (PP_FEATURE_DYNAMIC_DARK_FRAME_CORRECTION * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_HIGH_DYNAMIC_RANGE_ENABLED               = (PP_FEATURE_HIGH_DYNAMIC_RANGE * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DESPECKLE_BRIGHT_LOW_ENABLED             = (PP_FEATURE_DESPECKLE_BRIGHT_LOW * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DESPECKLE_BRIGHT_LOW_THRESHOLD,
    PP_FEATURE_DESPECKLE_BRIGHT_LOW_MAX_ADU_AFFECTED,
    PP_FEATURE_DENOISING_ENABLED                        = (PP_FEATURE_DENOISING * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DENOISING_NO_OF_ITERATIONS,
    PP_FEATURE_DENOISING_GAIN,
    PP_FEATURE_DENOISING_OFFSET,
    PP_FEATURE_DENOISING_LAMBDA,
    PP_FEATURE_DESPECKLE_DARK_HIGH_ENABLED              = (PP_FEATURE_DESPECKLE_DARK_HIGH * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_DESPECKLE_DARK_HIGH_THRESHOLD,
    PP_FEATURE_DESPECKLE_DARK_HIGH_MIN_ADU_AFFECTED,
    PP_FEATURE_ENHANCED_DYNAMIC_RANGE_ENABLED           = (PP_FEATURE_ENHANCED_DYNAMIC_RANGE * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_FRAME_SUMMING_ENABLED                    = (PP_FEATURE_FRAME_SUMMING * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_FEATURE_FRAME_SUMMING_COUNT,
    PP_FEATURE_FRAME_SUMMING_32_BIT_MODE,
    PP_FEATURE_LARGE_CLUSTER_CORRECTION_ENABLED         = (PP_FEATURE_LARGE_CLUSTER_CORRECTION * PP_MAX_PARAMETERS_PER_FEATURE),
    PP_PARAMETER_ID_MAX
}
PP_PARAMETER_IDS;

typedef struct smart_stream_type
{
    uns16   entries;    
    uns32*  params;     
}
smart_stream_type;

typedef enum PL_SMT_MODES
{
    SMTMODE_ARBITRARY_ALL = 0, 
    SMTMODE_MAX
}
PL_SMT_MODES;

typedef enum PL_IMAGE_STATUSES
{
    READOUT_NOT_ACTIVE,
    EXPOSURE_IN_PROGRESS,
    READOUT_IN_PROGRESS,
    READOUT_COMPLETE,
    FRAME_AVAILABLE = READOUT_COMPLETE,
    READOUT_FAILED,

    ACQUISITION_IN_PROGRESS, 
    /* Should be the last and never used value. */
    MAX_CAMERA_STATUS
}
PL_IMAGE_STATUSES;

typedef enum PL_CCS_ABORT_MODES
{
    CCS_NO_CHANGE = 0,
    CCS_HALT,
    CCS_HALT_CLOSE_SHTR,
    CCS_CLEAR,
    CCS_CLEAR_CLOSE_SHTR,
    CCS_OPEN_SHTR,
    CCS_CLEAR_OPEN_SHTR
}
PL_CCS_ABORT_MODES;

typedef enum PL_IRQ_MODES
{
    NO_FRAME_IRQS = 0,      
    BEGIN_FRAME_IRQS,       
    END_FRAME_IRQS,         
    BEGIN_END_FRAME_IRQS    
}
PL_IRQ_MODES;

typedef enum PL_CIRC_MODES
{
    CIRC_NONE = 0,
    CIRC_OVERWRITE,
    CIRC_NO_OVERWRITE
}
PL_CIRC_MODES;

typedef enum PL_EXP_RES_MODES
{
    EXP_RES_ONE_MILLISEC = 0, 
    EXP_RES_ONE_MICROSEC,     
    EXP_RES_ONE_SEC           
}
PL_EXP_RES_MODES;

typedef enum PL_SRC_MODES
{
    SCR_PRE_OPEN_SHTR = 0,
    SCR_POST_OPEN_SHTR,
    SCR_PRE_FLASH,
    SCR_POST_FLASH,
    SCR_PRE_INTEGRATE,
    SCR_POST_INTEGRATE,
    SCR_PRE_READOUT,
    SCR_POST_READOUT,
    SCR_PRE_CLOSE_SHTR,
    SCR_POST_CLOSE_SHTR
}
PL_SRC_MODES;

typedef enum PL_CALLBACK_EVENT
{
    PL_CALLBACK_BOF = 0,
    PL_CALLBACK_EOF,
    PL_CALLBACK_CHECK_CAMS,
    PL_CALLBACK_CAM_REMOVED,
    PL_CALLBACK_CAM_RESUMED,
    PL_CALLBACK_MAX
}
PL_CALLBACK_EVENT;

typedef struct rgn_type
{
    uns16 s1;   
    uns16 s2;   
    uns16 sbin; 
    uns16 p1;   
    uns16 p2;   
    uns16 pbin; 
}
rgn_type;

typedef struct io_struct
{
    uns16 io_port;          
    uns32 io_type;          
    flt64 state;            
    struct io_struct* next; 
}
io_entry;

typedef struct io_list
{
    io_entry pre_open;
    io_entry post_open;
    io_entry pre_flash;
    io_entry post_flash;
    io_entry pre_integrate;
    io_entry post_integrate;
    io_entry pre_readout;
    io_entry post_readout;
    io_entry pre_close;
    io_entry post_close;
}
io_list;

typedef struct active_camera_type
{
    uns16       shutter_close_delay; 
    uns16       shutter_open_delay;  
    uns16       rows;                
    uns16       cols;                
    uns16       prescan;             
    uns16       postscan;            
    uns16       premask;             
    uns16       postmask;            
    uns16       preflash;            
    uns16       clear_count;         
    uns16       preamp_delay;        
    rs_bool     mpp_selectable;      
    rs_bool     frame_selectable;    
    int16       do_clear;            
    int16       open_shutter;        
    rs_bool     mpp_mode;            
    rs_bool     frame_transfer;      
    rs_bool     alt_mode;            
    uns32       exp_res;             
    io_list*    io_hdr;              
}
active_camera_type;

/******************************************************************************/
/* Start of Frame Metadata Types                                              */
/******************************************************************************/

/******************************************************************************/
/* Data headers and camera shared types                                       */

typedef enum PL_MD_FRAME_FLAGS
{
    PL_MD_FRAME_FLAG_ROI_TS_SUPPORTED = 0x01,
    PL_MD_FRAME_FLAG_UNUSED_2         = 0x02,
    PL_MD_FRAME_FLAG_UNUSED_3         = 0x04,
    PL_MD_FRAME_FLAG_UNUSED_4         = 0x10,
    PL_MD_FRAME_FLAG_UNUSED_5         = 0x20,
    PL_MD_FRAME_FLAG_UNUSED_6         = 0x40,
    PL_MD_FRAME_FLAG_UNUSED_7         = 0x80
}
PL_MD_FRAME_FLAGS;

typedef enum PL_MD_ROI_FLAGS
{
    PL_MD_ROI_FLAG_INVALID      = 0x01,
    PL_MD_ROI_FLAG_HEADER_ONLY  = 0x02,
    PL_MD_ROI_FLAG_UNUSED_3     = 0x04,
    PL_MD_ROI_FLAG_UNUSED_4     = 0x10,
    PL_MD_ROI_FLAG_UNUSED_5     = 0x20,
    PL_MD_ROI_FLAG_UNUSED_6     = 0x40,
    PL_MD_ROI_FLAG_UNUSED_7     = 0x80
}
PL_MD_ROI_FLAGS;

#define PL_MD_FRAME_SIGNATURE 5328208

/*
The structures are shared between platforms, thus we must ensure that no
compiler will apply different struct alignment.
*/
#pragma pack(push)
#pragma pack(1)

typedef struct md_frame_header
{                                 /* TOTAL: 48 bytes */
    uns32       signature;        
    uns8        version;          
    uns32       frameNr;          
    uns16       roiCount;         
    uns32       timestampBOF;     
    uns32       timestampEOF;     
    uns32       timestampResNs;   
    uns32       exposureTime;     
    uns32       exposureTimeResNs;
    uns32       roiTimestampResNs;
    uns8        bitDepth;         
    uns8        colorMask;        
    uns8        flags;            
    uns16       extendedMdSize;   
    uns8        imageFormat;      
    uns8        imageCompression; 
    uns8        _reserved[6];
}
md_frame_header;

typedef struct md_frame_header_v3
{                                 /* TOTAL: 48 bytes */
    uns32       signature;        
    uns8        version;          
    uns32       frameNr;          
    uns16       roiCount;         
    ulong64     timestampBOF;     
    ulong64     timestampEOF;     
    ulong64     exposureTime;     
    uns8        bitDepth;         
    uns8        colorMask;        
    uns8        flags;            
    uns16       extendedMdSize;   
    uns8        imageFormat;      
    uns8        imageCompression; 
    uns8        _reserved[6];
}
md_frame_header_v3;

typedef struct md_frame_roi_header
{                              /* TOTAL: 32 bytes */
    uns16    roiNr;            
    uns32    timestampBOR;     
    uns32    timestampEOR;     
    rgn_type roi;              
    uns8     flags;            
    uns16    extendedMdSize;   
    uns32    roiDataSize;      
    uns8    _reserved[3];
}
md_frame_roi_header;

#pragma pack(pop)

/******************************************************************************/
/* Extended metadata related structures                                       */

#define PL_MD_EXT_TAGS_MAX_SUPPORTED 255

typedef enum PL_MD_EXT_TAGS
{
    PL_MD_EXT_TAG_PARTICLE_ID = 0, 
    PL_MD_EXT_TAG_PARTICLE_M0,     
    PL_MD_EXT_TAG_PARTICLE_M2,     
    PL_MD_EXT_TAG_MAX
}
PL_MD_EXT_TAGS;

typedef struct md_ext_item_info
{
    PL_MD_EXT_TAGS tag;   
    uns16          type;  
    uns16          size;  
    const char*    name;  
}
md_ext_item_info;

typedef struct md_ext_item
{
    const md_ext_item_info* tagInfo; 
    void*                   value;   
}
md_ext_item;

typedef struct md_ext_item_collection
{
    md_ext_item     list[PL_MD_EXT_TAGS_MAX_SUPPORTED]; 
    md_ext_item*    map[PL_MD_EXT_TAGS_MAX_SUPPORTED];  
    uns16           count;                              
}
md_ext_item_collection;

typedef struct md_frame_roi
{
    md_frame_roi_header*    header;         
    void*                   data;           
    uns32                   dataSize;       
    void*                   extMdData;      
    uns16                   extMdDataSize;  
}
md_frame_roi;

typedef struct md_frame
{
    md_frame_header*     header;       
    void*                extMdData;    
    uns16                extMdDataSize;
    rgn_type             impliedRoi;   
    md_frame_roi*        roiArray;     
    uns16                roiCapacity;  
    uns16                roiCount;     
}
md_frame;

/******************************************************************************/
/*End of Frame Metadata Types                                                 */
/******************************************************************************/

/******************************************************************************/
typedef PVCAM_FRAME_INFO_GUID*  PPVCAM_FRAME_INFO_GUID;
typedef FRAME_INFO*             PFRAME_INFO;
typedef smart_stream_type*      smart_stream_type_ptr;
typedef rgn_type*               rgn_ptr;
typedef const rgn_type*         rgn_const_ptr;
typedef io_entry*               io_entry_ptr;
typedef io_list*                io_list_ptr;
typedef io_list**               io_list_ptr_ptr;
typedef active_camera_type*     active_camera_ptr;
 /* grp_pm_deprecated_typedefs */

/******************************************************************************/
#define MS16_BYTE(two_byte_value)((uns8)(((uns16)(two_byte_value) >> 8) & 0xFF))

#define LS16_BYTE(two_byte_value)((uns8)(((uns16)(two_byte_value) >> 0) & 0xFF))

#define MS32_BYTE(four_byte_value)((uns8)(((uns32)(four_byte_value) >> 24) & 0xFF))

#define MH32_BYTE(four_byte_value)((uns8)(((uns32)(four_byte_value) >> 16) & 0xFF))

#define ML32_BYTE(four_byte_value)((uns8)(((uns32)(four_byte_value) >>  8) & 0xFF))

#define LS32_BYTE(four_byte_value)((uns8)(((uns32)(four_byte_value) >>  0) & 0xFF))

#define VAL_UNS16(ms_byte,ls_byte)(\
    ((uns16)((uns8)(ms_byte)) << 8) |\
    ((uns16)((uns8)(ls_byte)) << 0))

#define VAL_UNS32(ms_byte,mh_byte,ml_byte,ls_byte)(\
    ((uns32)((uns8)(ms_byte)) << 24) |\
    ((uns32)((uns8)(mh_byte)) << 16) |\
    ((uns32)((uns8)(ml_byte)) <<  8) |\
    ((uns32)((uns8)(ls_byte)) <<  0))

#define VAL_INT64(b0,b1,b2,b3,b4,b5,b6,b7)(\
    ((long64)((uns8)(b0)) << 56) |\
    ((long64)((uns8)(b1)) << 48) |\
    ((long64)((uns8)(b2)) << 40) |\
    ((long64)((uns8)(b3)) << 32) |\
    ((long64)((uns8)(b4)) << 24) |\
    ((long64)((uns8)(b5)) << 16) |\
    ((long64)((uns8)(b6)) <<  8) |\
    ((long64)((uns8)(b7)) <<  0))

/******************************************************************************/
/* Content which is needed to communicate with the PVCAM DLLs */

typedef int16 pm_script_hook(int16 hcam,
                             uns16 exp_total,
                             uns16 rgn_total,
                             const rgn_type* rgn_array,
                             int16 mode,
                             uns32 exposure_time,
                             uns32* pixels,
                             active_camera_type* active_camera);

#define TYPE_INT16                  1
#define TYPE_INT32                  2
#define TYPE_FLT64                  4
#define TYPE_UNS8                   5
#define TYPE_UNS16                  6
#define TYPE_UNS32                  7
#define TYPE_UNS64                  8
#define TYPE_ENUM                   9
#define TYPE_BOOLEAN               11
#define TYPE_INT8                  12
#define TYPE_CHAR_PTR              13
#define TYPE_VOID_PTR              14
#define TYPE_VOID_PTR_PTR          15
#define TYPE_INT64                 16
#define TYPE_SMART_STREAM_TYPE     17
#define TYPE_SMART_STREAM_TYPE_PTR 18
#define TYPE_FLT32                 19

/*
Defines for classes.
*/
#define CLASS0      0          /* Camera Communications */
#define CLASS2      2          /* Configuration/Setup */
#define CLASS3      3          /* Data Acquisition */

/******************************************************************************/
/* Start of parameter ID definitions.                                         */
/* Format: TTCCxxxx, where TT = Data type, CC = Class, xxxx = ID number       */
/* Please note that some data types encoded in the parameter IDs do not       */
/* correspond to the actual parameter data type. Please always check the      */
/* ATTR_TYPE before using the parameter.                                      */
/******************************************************************************/

/* CAMERA COMMUNICATION PARAMETERS */

#define PARAM_DD_INFO_LENGTH        ((CLASS0<<16) + (TYPE_INT16<<24) + 1)

#define PARAM_DD_VERSION            ((CLASS0<<16) + (TYPE_UNS16<<24) + 2)

#define PARAM_DD_RETRIES            ((CLASS0<<16) + (TYPE_UNS16<<24) + 3)

#define PARAM_DD_TIMEOUT            ((CLASS0<<16) + (TYPE_UNS16<<24) + 4)

#define PARAM_DD_INFO               ((CLASS0<<16) + (TYPE_CHAR_PTR<<24) + 5)

#define PARAM_CAM_INTERFACE_TYPE    ((CLASS0<<16) + (TYPE_ENUM<<24) + 10)

#define PARAM_CAM_INTERFACE_MODE    ((CLASS0<<16) + (TYPE_ENUM<<24) + 11)

/* CONFIGURATION AND SETUP PARAMETERS */

#define PARAM_ADC_OFFSET            ((CLASS2<<16) + (TYPE_INT16<<24)     + 195)

#define PARAM_CHIP_NAME             ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 129)

#define PARAM_SYSTEM_NAME           ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 130)

#define PARAM_VENDOR_NAME           ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 131)

#define PARAM_PRODUCT_NAME          ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 132)

#define PARAM_CAMERA_PART_NUMBER    ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 133)

#define PARAM_COOLING_MODE          ((CLASS2<<16) + (TYPE_ENUM<<24)      + 214)

#define PARAM_PREAMP_DELAY          ((CLASS2<<16) + (TYPE_UNS16<<24)     + 502)

#define PARAM_COLOR_MODE            ((CLASS2<<16) + (TYPE_ENUM<<24)      + 504)

#define PARAM_MPP_CAPABLE           ((CLASS2<<16) + (TYPE_ENUM<<24)      + 224)

#define PARAM_PREAMP_OFF_CONTROL    ((CLASS2<<16) + (TYPE_UNS32<<24)     + 507)

/* Sensor dimensions and physical characteristics */

#define PARAM_PREMASK               ((CLASS2<<16) + (TYPE_UNS16<<24)     +  53)

#define PARAM_PRESCAN               ((CLASS2<<16) + (TYPE_UNS16<<24)     +  55)

#define PARAM_POSTMASK              ((CLASS2<<16) + (TYPE_UNS16<<24)     +  54)

#define PARAM_POSTSCAN              ((CLASS2<<16) + (TYPE_UNS16<<24)     +  56)

#define PARAM_PIX_PAR_DIST          ((CLASS2<<16) + (TYPE_UNS16<<24)     + 500)

#define PARAM_PIX_PAR_SIZE          ((CLASS2<<16) + (TYPE_UNS16<<24)     +  63)

#define PARAM_PIX_SER_DIST          ((CLASS2<<16) + (TYPE_UNS16<<24)     + 501)

#define PARAM_PIX_SER_SIZE          ((CLASS2<<16) + (TYPE_UNS16<<24)     +  62)

#define PARAM_SUMMING_WELL          ((CLASS2<<16) + (TYPE_BOOLEAN<<24)   + 505)

#define PARAM_FWELL_CAPACITY        ((CLASS2<<16) + (TYPE_UNS32<<24)     + 506)

#define PARAM_PAR_SIZE              ((CLASS2<<16) + (TYPE_UNS16<<24)     +  57)

#define PARAM_SER_SIZE              ((CLASS2<<16) + (TYPE_UNS16<<24)     +  58)

#define PARAM_ACCUM_CAPABLE         ((CLASS2<<16) + (TYPE_BOOLEAN<<24)   + 538)

#define PARAM_FLASH_DWNLD_CAPABLE   ((CLASS2<<16) + (TYPE_BOOLEAN<<24)   + 539)

/* General parameters */

#define PARAM_READOUT_TIME          ((CLASS2<<16) + (TYPE_FLT64<<24)     + 179)

#define PARAM_CLEARING_TIME         ((CLASS2<<16) + (TYPE_INT64<<24)     + 180)

#define PARAM_POST_TRIGGER_DELAY    ((CLASS2<<16) + (TYPE_INT64<<24)     + 181)

#define PARAM_PRE_TRIGGER_DELAY     ((CLASS2<<16) + (TYPE_INT64<<24)     + 182)

/* CAMERA PARAMETERS */

#define PARAM_CLEAR_CYCLES          ((CLASS2<<16) + (TYPE_UNS16<<24)     +  97)

#define PARAM_CLEAR_MODE            ((CLASS2<<16) + (TYPE_ENUM<<24)      + 523)

#define PARAM_FRAME_CAPABLE         ((CLASS2<<16) + (TYPE_BOOLEAN<<24)   + 509)

#define PARAM_PMODE                 ((CLASS2<<16) + (TYPE_ENUM <<24)     + 524)

/* Temperature parameters for the detector. */

#define PARAM_TEMP                  ((CLASS2<<16) + (TYPE_INT16<<24)     + 525)

#define PARAM_TEMP_SETPOINT         ((CLASS2<<16) + (TYPE_INT16<<24)     + 526)

/* Parameters used for firmware version retrieval. */

#define PARAM_CAM_FW_VERSION        ((CLASS2<<16) + (TYPE_UNS16<<24)     + 532)

#define PARAM_HEAD_SER_NUM_ALPHA    ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 533)

#define PARAM_PCI_FW_VERSION        ((CLASS2<<16) + (TYPE_UNS16<<24)     + 534)

#define PARAM_FAN_SPEED_SETPOINT    ((CLASS2<<16) + (TYPE_ENUM<<24)      + 710)

#define PARAM_CAM_SYSTEMS_INFO      ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 536)

#define PARAM_EXPOSURE_MODE         ((CLASS2<<16) + (TYPE_ENUM<<24)      + 535)

#define PARAM_EXPOSE_OUT_MODE       ((CLASS2<<16) + (TYPE_ENUM<<24)      + 560)

/* SPEED TABLE PARAMETERS */

#define PARAM_BIT_DEPTH             ((CLASS2<<16) + (TYPE_INT16<<24)     + 511)

#define PARAM_IMAGE_FORMAT          ((CLASS2<<16) + (TYPE_ENUM<<24)      + 248)

#define PARAM_IMAGE_COMPRESSION     ((CLASS2<<16) + (TYPE_ENUM<<24)      + 249)

#define PARAM_SCAN_MODE             ((CLASS3<<16) + (TYPE_ENUM<<24)      + 250)

#define PARAM_SCAN_DIRECTION                ((CLASS3<<16) + (TYPE_ENUM<<24)      + 251)

#define PARAM_SCAN_DIRECTION_RESET          ((CLASS3<<16) + (TYPE_BOOLEAN<<24)      + 252)

#define PARAM_SCAN_LINE_DELAY               ((CLASS3<<16) + (TYPE_UNS16<<24)      + 253)

#define PARAM_SCAN_LINE_TIME                ((CLASS3<<16) + (TYPE_INT64<<24)      + 254)

#define PARAM_SCAN_WIDTH                    ((CLASS3<<16) + (TYPE_UNS16<<24)      + 255)

#define PARAM_FRAME_ROTATE                  ((CLASS2<<16) + (TYPE_ENUM<<24)      + 256)

#define PARAM_FRAME_FLIP                    ((CLASS2<<16) + (TYPE_ENUM<<24)      + 257)

#define PARAM_GAIN_INDEX            ((CLASS2<<16) + (TYPE_INT16<<24)     + 512)

#define PARAM_SPDTAB_INDEX          ((CLASS2<<16) + (TYPE_INT16<<24)     + 513)

#define PARAM_GAIN_NAME             ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)  + 514)

#define PARAM_SPDTAB_NAME          ((CLASS2<<16) + (TYPE_CHAR_PTR<<24)   + 515)

#define PARAM_READOUT_PORT          ((CLASS2<<16) + (TYPE_ENUM<<24)      + 247)

#define PARAM_PIX_TIME              ((CLASS2<<16) + (TYPE_UNS16<<24)     + 516)

/* SHUTTER PARAMETERS */

#define PARAM_SHTR_CLOSE_DELAY      ((CLASS2<<16) + (TYPE_UNS16<<24)     + 519)

#define PARAM_SHTR_OPEN_DELAY       ((CLASS2<<16) + (TYPE_UNS16<<24)     + 520)

#define PARAM_SHTR_OPEN_MODE        ((CLASS2<<16) + (TYPE_ENUM <<24)     + 521)

#define PARAM_SHTR_STATUS           ((CLASS2<<16) + (TYPE_ENUM <<24)     + 522)

/* I/O PARAMETERS */

#define PARAM_IO_ADDR               ((CLASS2<<16) + (TYPE_UNS16<<24)     + 527)

#define PARAM_IO_TYPE               ((CLASS2<<16) + (TYPE_ENUM<<24)      + 528)

#define PARAM_IO_DIRECTION          ((CLASS2<<16) + (TYPE_ENUM<<24)      + 529)

#define PARAM_IO_STATE              ((CLASS2<<16) + (TYPE_FLT64<<24)     + 530)

#define PARAM_IO_BITDEPTH           ((CLASS2<<16) + (TYPE_UNS16<<24)     + 531)

/* GAIN MULTIPLIER PARAMETERS */

#define PARAM_GAIN_MULT_FACTOR      ((CLASS2<<16) + (TYPE_UNS16<<24)     + 537)

#define PARAM_GAIN_MULT_ENABLE      ((CLASS2<<16) + (TYPE_BOOLEAN<<24)   + 541)

/* POST PROCESSING PARAMETERS */

#define PARAM_PP_FEAT_NAME          ((CLASS2<<16) + (TYPE_CHAR_PTR<<24) +  542)

#define PARAM_PP_INDEX              ((CLASS2<<16) + (TYPE_INT16<<24)    +  543)

#define PARAM_ACTUAL_GAIN           ((CLASS2<<16) + (TYPE_UNS16<<24)     + 544)

#define PARAM_PP_PARAM_INDEX        ((CLASS2<<16) + (TYPE_INT16<<24)    +  545)

#define PARAM_PP_PARAM_NAME         ((CLASS2<<16) + (TYPE_CHAR_PTR<<24) +  546)

#define PARAM_PP_PARAM              ((CLASS2<<16) + (TYPE_UNS32<<24)    +  547)

#define PARAM_READ_NOISE            ((CLASS2<<16) + (TYPE_UNS16<<24)     + 548)

#define PARAM_PP_FEAT_ID            ((CLASS2<<16) + (TYPE_UNS16<<24)    +  549)

#define PARAM_PP_PARAM_ID           ((CLASS2<<16) + (TYPE_UNS16<<24)    +  550)

/* S.M.A.R.T. STREAMING PARAMETERS */

#define PARAM_SMART_STREAM_MODE_ENABLED     ((CLASS2<<16) + (TYPE_BOOLEAN<<24)  +  700)

#define PARAM_SMART_STREAM_MODE             ((CLASS2<<16) + (TYPE_UNS16<<24)    +  701)

#define PARAM_SMART_STREAM_EXP_PARAMS       ((CLASS2<<16) + (TYPE_VOID_PTR<<24) +  702)

#define PARAM_SMART_STREAM_DLY_PARAMS       ((CLASS2<<16) + (TYPE_VOID_PTR<<24) +  703)

/* ACQUISITION PARAMETERS */

#define PARAM_EXP_TIME              ((CLASS3<<16) + (TYPE_UNS16<<24)     +   1)

#define PARAM_EXP_RES               ((CLASS3<<16) + (TYPE_ENUM<<24)      +   2)

#define PARAM_EXP_RES_INDEX         ((CLASS3<<16) + (TYPE_UNS16<<24)     +   4)

#define PARAM_EXPOSURE_TIME         ((CLASS3<<16) + (TYPE_UNS64<<24)     +   8)

/* PARAMETERS FOR  BEGIN and END of FRAME Interrupts */

#define PARAM_BOF_EOF_ENABLE        ((CLASS3<<16) + (TYPE_ENUM<<24)      +   5)

#define PARAM_BOF_EOF_COUNT         ((CLASS3<<16) + (TYPE_UNS32<<24)     +   6)

#define PARAM_BOF_EOF_CLR           ((CLASS3<<16) + (TYPE_BOOLEAN<<24)   +   7)

#define PARAM_CIRC_BUFFER           ((CLASS3<<16) + (TYPE_BOOLEAN<<24)   + 299)

#define PARAM_FRAME_BUFFER_SIZE     ((CLASS3<<16) + (TYPE_UNS64<<24)     + 300)

/* Binning reported by camera */

#define PARAM_BINNING_SER           ((CLASS3<<16) + (TYPE_ENUM<<24)      + 165)

#define PARAM_BINNING_PAR           ((CLASS3<<16) + (TYPE_ENUM<<24)      + 166)

/* Parameters related to multiple ROIs and Centroids */

#define PARAM_METADATA_ENABLED      ((CLASS3<<16) + (TYPE_BOOLEAN<<24)   + 168)

#define PARAM_METADATA_RESET_TIMESTAMP ((CLASS3<<16) + (TYPE_BOOLEAN<<24) + 176)

#define PARAM_ROI_COUNT             ((CLASS3<<16) + (TYPE_UNS16  <<24)   + 169)

#define PARAM_CENTROIDS_ENABLED     ((CLASS3<<16) + (TYPE_BOOLEAN<<24)   + 170)

#define PARAM_CENTROIDS_RADIUS      ((CLASS3<<16) + (TYPE_UNS16  <<24)   + 171)

#define PARAM_CENTROIDS_COUNT       ((CLASS3<<16) + (TYPE_UNS16  <<24)   + 172)

#define PARAM_CENTROIDS_MODE        ((CLASS3<<16) + (TYPE_ENUM   <<24)   + 173)

#define PARAM_CENTROIDS_BG_COUNT    ((CLASS3<<16) + (TYPE_ENUM   <<24)   + 174)

#define PARAM_CENTROIDS_THRESHOLD   ((CLASS3<<16) + (TYPE_UNS32  <<24)   + 175)

/* Parameters related to triggering table */

#define PARAM_TRIGTAB_SIGNAL        ((CLASS3<<16) + (TYPE_ENUM<<24)      + 180)

#define PARAM_LAST_MUXED_SIGNAL     ((CLASS3<<16) + (TYPE_UNS8<<24)      + 181)

#define PARAM_FRAME_DELIVERY_MODE   ((CLASS3<<16) + (TYPE_ENUM <<24)     + 400)
 /* grp_pm_parameters */

/******************************************************************************/
/* End of parameter ID definitions.                                           */
/******************************************************************************/

/******************************************************************************/
/* Start of function prototypes.                                              */
/******************************************************************************/

#ifndef PV_EMBEDDED

typedef void (PV_DECL *PL_CALLBACK_SIG_LEGACY)(void);

typedef void (PV_DECL *PL_CALLBACK_SIG_EX)(void* pContext);

typedef void (PV_DECL *PL_CALLBACK_SIG_EX2)(const FRAME_INFO* pFrameInfo);

typedef void (PV_DECL *PL_CALLBACK_SIG_EX3)(const FRAME_INFO* pFrameInfo, void* pContext);
 /* grp_callbacks */

#ifdef PV_C_PLUS_PLUS
extern "C"
{
#endif

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                 Camera Communications Function Prototypes                 */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

rs_bool PV_DECL pl_pvcam_get_ver(uns16* pvcam_version);

rs_bool PV_DECL pl_pvcam_init(void);

rs_bool PV_DECL pl_pvcam_uninit(void);
 /* grp_pm_functions */

DEPRECATED rs_bool PV_DECL pl_cam_check(int16 hcam); /* grp_pm_deprecated_functions */

rs_bool PV_DECL pl_cam_close(int16 hcam);

rs_bool PV_DECL pl_cam_get_name(int16 cam_num, char* camera_name);

rs_bool PV_DECL pl_cam_get_total(int16* totl_cams);

rs_bool PV_DECL pl_cam_open(char* camera_name, int16* hcam, int16 o_mode);
 /* grp_pm_functions */

DEPRECATED rs_bool PV_DECL pl_cam_register_callback(int16 hcam, int32 callback_event,
                                                    void* callback);
DEPRECATED rs_bool PV_DECL pl_cam_register_callback_ex(int16 hcam, int32 callback_event,
                                                       void* callback, void* context);
DEPRECATED rs_bool PV_DECL pl_cam_register_callback_ex2(int16 hcam, int32 callback_event,
                                                        void* callback); /* grp_pm_deprecated_functions */

rs_bool PV_DECL pl_cam_register_callback_ex3(int16 hcam, int32 callback_event,
                                             void* callback, void* context);

rs_bool PV_DECL pl_cam_deregister_callback(int16 hcam, int32 callback_event);

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                     Error Reporting Function Prototypes                   */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

int16   PV_DECL pl_error_code(void);

rs_bool PV_DECL pl_error_message(int16 err_code, char* msg);

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                   Configuration/Setup Function Prototypes                 */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

rs_bool PV_DECL pl_get_param(int16 hcam, uns32 param_id,
                             int16 param_attribute, void* param_value);

rs_bool PV_DECL pl_set_param(int16 hcam, uns32 param_id, void* param_value);

rs_bool PV_DECL pl_get_enum_param(int16 hcam, uns32 param_id, uns32 index,
                                  int32* value, char* desc, uns32 length);

rs_bool PV_DECL pl_enum_str_length(int16 hcam, uns32 param_id, uns32 index,
                                   uns32* length);

rs_bool PV_DECL pl_pp_reset(int16 hcam);

rs_bool PV_DECL pl_create_smart_stream_struct(smart_stream_type** array,
                                              uns16 entries);

rs_bool PV_DECL pl_release_smart_stream_struct(smart_stream_type** array);

rs_bool PV_DECL pl_create_frame_info_struct(FRAME_INFO** new_frame);

rs_bool PV_DECL pl_release_frame_info_struct(FRAME_INFO* frame_to_delete);

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                   Data Acquisition Function Prototypes                    */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

rs_bool PV_DECL pl_exp_setup_seq(int16 hcam, uns16 exp_total, uns16 rgn_total,
                                 const rgn_type* rgn_array, int16 exp_mode,
                                 uns32 exposure_time, uns32* exp_bytes);

rs_bool PV_DECL pl_exp_start_seq(int16 hcam, void* pixel_stream);

rs_bool PV_DECL pl_exp_setup_cont(int16 hcam, uns16 rgn_total,
                                  const rgn_type* rgn_array, int16 exp_mode,
                                  uns32 exposure_time, uns32* exp_bytes,
                                  int16 buffer_mode);

rs_bool PV_DECL pl_exp_start_cont(int16 hcam, void* pixel_stream, uns32 size);

rs_bool PV_DECL pl_exp_trigger(int16 hcam, uns32* flags, uns32 value);

rs_bool PV_DECL pl_exp_check_status(int16 hcam, int16* status, uns32* bytes_arrived);

rs_bool PV_DECL pl_exp_check_cont_status(int16 hcam, int16* status,
                                         uns32* bytes_arrived, uns32* buffer_cnt);

rs_bool PV_DECL pl_exp_check_cont_status_ex(int16 hcam, int16* status,
                                            uns32* byte_cnt, uns32* buffer_cnt,
                                            FRAME_INFO* frame_info);

rs_bool PV_DECL pl_exp_get_latest_frame(int16 hcam, void** frame);

rs_bool PV_DECL pl_exp_get_latest_frame_ex(int16 hcam, void** frame,
                                           FRAME_INFO* frame_info);

rs_bool PV_DECL pl_exp_get_oldest_frame(int16 hcam, void** frame);

rs_bool PV_DECL pl_exp_get_oldest_frame_ex(int16 hcam, void** frame,
                                           FRAME_INFO* frame_info);

rs_bool PV_DECL pl_exp_unlock_oldest_frame(int16 hcam);

rs_bool PV_DECL pl_exp_stop_cont(int16 hcam, int16 cam_state);

rs_bool PV_DECL pl_exp_abort(int16 hcam, int16 cam_state);

rs_bool PV_DECL pl_exp_finish_seq(int16 hcam, void* pixel_stream, int16 hbuf);

rs_bool PV_DECL pl_io_script_control(int16 hcam, uns16 addr, flt64 state,
                                     uns32 location);

rs_bool PV_DECL pl_io_clear_script_control(int16 hcam);
 /* grp_pm_functions */

/*****************************************************************************/
DEPRECATED rs_bool PV_DECL pl_exp_init_seq(void);
DEPRECATED rs_bool PV_DECL pl_exp_uninit_seq(void);
DEPRECATED rs_bool PV_DECL pl_dd_get_info(int16 hcam, int16 bytes, char* text);
DEPRECATED rs_bool PV_DECL pl_dd_get_info_length(int16 hcam, int16* bytes);
DEPRECATED rs_bool PV_DECL pl_dd_get_ver(int16 hcam, uns16* dd_version);
DEPRECATED rs_bool PV_DECL pl_dd_get_retries(int16 hcam, uns16* max_retries);
DEPRECATED rs_bool PV_DECL pl_dd_set_retries(int16 hcam, uns16 max_retries);
DEPRECATED rs_bool PV_DECL pl_dd_get_timeout(int16 hcam, uns16* m_sec);
DEPRECATED rs_bool PV_DECL pl_dd_set_timeout(int16 hcam, uns16 m_sec);
DEPRECATED rs_bool PV_DECL pl_ccd_get_adc_offset(int16 hcam, int16* offset);
DEPRECATED rs_bool PV_DECL pl_ccd_set_adc_offset(int16 hcam, int16 offset);
DEPRECATED rs_bool PV_DECL pl_ccd_get_chip_name(int16 hcam, char* chip_name);
DEPRECATED rs_bool PV_DECL pl_ccd_get_clear_cycles(int16 hcam, uns16* clear_cycles);
DEPRECATED rs_bool PV_DECL pl_ccd_set_clear_cycles(int16 hcam, uns16 clr_cycles);
DEPRECATED rs_bool PV_DECL pl_ccd_get_clear_mode(int16 hcam, int16* clear_mode);
DEPRECATED rs_bool PV_DECL pl_ccd_set_clear_mode(int16 hcam, int16 ccd_clear);
DEPRECATED rs_bool PV_DECL pl_ccd_get_color_mode(int16 hcam, uns16* color_mode);
DEPRECATED rs_bool PV_DECL pl_ccd_get_cooling_mode(int16 hcam, int16* cooling);
DEPRECATED rs_bool PV_DECL pl_ccd_get_frame_capable(int16 hcam, rs_bool* frame_capable);
DEPRECATED rs_bool PV_DECL pl_ccd_get_fwell_capacity(int16 hcam, uns32* fwell_capacity);
DEPRECATED rs_bool PV_DECL pl_ccd_get_mpp_capable(int16 hcam, int16* mpp_capable);
DEPRECATED rs_bool PV_DECL pl_ccd_get_preamp_dly(int16 hcam, uns16* preamp_dly);
DEPRECATED rs_bool PV_DECL pl_ccd_get_preamp_off_control(int16 hcam,
                                                         uns32* preamp_off_control);
DEPRECATED rs_bool PV_DECL pl_ccd_set_preamp_off_control(int16 hcam,
                                                         uns32 preamp_off_control);
DEPRECATED rs_bool PV_DECL pl_ccd_get_preflash(int16 hcam, uns16* pre_flash);
DEPRECATED rs_bool PV_DECL pl_ccd_get_pmode(int16 hcam, int16* pmode);
DEPRECATED rs_bool PV_DECL pl_ccd_set_pmode(int16 hcam, int16 pmode);
DEPRECATED rs_bool PV_DECL pl_ccd_get_premask(int16 hcam, uns16* pre_mask);
DEPRECATED rs_bool PV_DECL pl_ccd_get_prescan(int16 hcam, uns16* prescan);
DEPRECATED rs_bool PV_DECL pl_ccd_get_postmask(int16 hcam, uns16* post_mask);
DEPRECATED rs_bool PV_DECL pl_ccd_get_postscan(int16 hcam, uns16* postscan);
DEPRECATED rs_bool PV_DECL pl_ccd_get_par_size(int16 hcam, uns16* par_size);
DEPRECATED rs_bool PV_DECL pl_ccd_get_ser_size(int16 hcam, uns16* ser_size);
DEPRECATED rs_bool PV_DECL pl_ccd_get_serial_num(int16 hcam, uns16* serial_num);
DEPRECATED rs_bool PV_DECL pl_ccs_get_status(int16 hcam, int16* ccs_status);
DEPRECATED rs_bool PV_DECL pl_ccd_get_summing_well(int16 hcam, rs_bool* s_well_exists);
DEPRECATED rs_bool PV_DECL pl_ccd_get_tmp(int16 hcam, int16* cur_tmp);
DEPRECATED rs_bool PV_DECL pl_ccd_get_tmp_range(int16 hcam, int16* tmp_hi_val,
                                                int16* tmp_lo_val);
DEPRECATED rs_bool PV_DECL pl_ccd_get_tmp_setpoint(int16 hcam, int16* tmp_setpoint);
DEPRECATED rs_bool PV_DECL pl_ccd_set_tmp_setpoint(int16 hcam, int16 tmp_setpoint);
DEPRECATED rs_bool PV_DECL pl_ccd_set_readout_port(int16 , int16 );
DEPRECATED rs_bool PV_DECL pl_ccd_get_pix_par_dist(int16 hcam, uns16* pix_par_dist);
DEPRECATED rs_bool PV_DECL pl_ccd_get_pix_par_size(int16 hcam, uns16* pix_par_size);
DEPRECATED rs_bool PV_DECL pl_ccd_get_pix_ser_dist(int16 hcam, uns16* pix_ser_dist);
DEPRECATED rs_bool PV_DECL pl_ccd_get_pix_ser_size(int16 hcam, uns16* pix_ser_size);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_bits(int16 hcam, int16* spdtab_bits);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_gain(int16 hcam, int16* spdtab_gain);
DEPRECATED rs_bool PV_DECL pl_spdtab_set_gain(int16 hcam, int16 spdtab_gain);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_max_gain(int16 hcam, int16* spdtab_max_gain);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_num(int16 hcam, int16* spdtab_num);
DEPRECATED rs_bool PV_DECL pl_spdtab_set_num(int16 hcam, int16 spdtab_num);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_entries(int16 hcam, int16* spdtab_entries);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_port(int16 hcam, int16* spdtab_port);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_port_total(int16 hcam, int16* total_ports);
DEPRECATED rs_bool PV_DECL pl_spdtab_get_time(int16 hcam, uns16* spdtab_time);
DEPRECATED rs_bool PV_DECL pl_shtr_get_close_dly(int16 hcam, uns16* shtr_close_dly);
DEPRECATED rs_bool PV_DECL pl_shtr_set_close_dly(int16 hcam, uns16 shtr_close_dly);
DEPRECATED rs_bool PV_DECL pl_shtr_get_open_dly(int16 hcam, uns16* shtr_open_dly);
DEPRECATED rs_bool PV_DECL pl_shtr_set_open_dly(int16 hcam, uns16 shtr_open_dly);
DEPRECATED rs_bool PV_DECL pl_shtr_get_open_mode(int16 hcam, int16* shtr_open_mode);
DEPRECATED rs_bool PV_DECL pl_shtr_set_open_mode(int16 hcam, int16 shtr_open_mode);
DEPRECATED rs_bool PV_DECL pl_shtr_get_status(int16 hcam, int16* shtr_status);
DEPRECATED rs_bool PV_DECL pl_exp_get_time_seq(int16 hcam, uns16* exp_time);
DEPRECATED rs_bool PV_DECL pl_exp_set_time_seq(int16 hcam, uns16 exp_time);
DEPRECATED rs_bool PV_DECL pl_exp_check_progress(int16 hcam, int16* status,
                                                 uns32* bytes_arrived);

DEPRECATED rs_bool PV_DECL pl_exp_set_cont_mode(int16 hcam, int16 mode);
DEPRECATED rs_bool PV_DECL pl_subsys_do_diag(int16 hcam, uns8 subsys_id,
                                             uns16* err_code);
DEPRECATED rs_bool PV_DECL pl_subsys_get_id(int16 hcam, uns8 subsys_id,
                                            uns16* part_num, uns8* revision);
DEPRECATED rs_bool PV_DECL pl_subsys_get_name(int16 hcam, uns8 subsys_id,
                                              char* subsys_name);
DEPRECATED rs_bool PV_DECL pl_exp_get_driver_buffer(int16 hcam,
                                                    void** pixel_stream,
                                                    uns32* byte_cnt);
DEPRECATED rs_bool PV_DECL pl_buf_init(void);
DEPRECATED rs_bool PV_DECL pl_buf_uninit(void);
DEPRECATED rs_bool PV_DECL pl_buf_alloc(int16* hbuf, int16 exp_total,
                                        int16 bit_depth, int16 rgn_total,
                                        const rgn_type* rgn_array);
DEPRECATED rs_bool PV_DECL pl_buf_get_exp_date(int16 hbuf, int16 exp_num, int16* year,
                                               uns8* month, uns8* day, uns8* hour,
                                               uns8* min, uns8* sec, uns16* msec);
DEPRECATED rs_bool PV_DECL pl_buf_set_exp_date(int16 hbuf, int16 exp_num, int16 year,
                                               uns8 month, uns8 day, uns8 hour,
                                               uns8 min, uns8 sec, uns16 msec);
DEPRECATED rs_bool PV_DECL pl_buf_get_exp_time(int16 hbuf, int16 exp_num, uns32* exp_msec);
DEPRECATED rs_bool PV_DECL pl_buf_get_exp_total(int16 hbuf, int16* total_exps);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_bin(int16 himg, int16* ibin, int16* jbin);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_handle(int16 hbuf, int16 exp_num,
                                                 int16 img_num, int16* himg);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_ofs(int16 himg, int16* s_ofs, int16* p_ofs);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_ptr(int16 himg, void** img_addr);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_size(int16 himg, int16* x_size, int16* y_size);
DEPRECATED rs_bool PV_DECL pl_buf_get_img_total(int16 hbuf, int16* totl_imgs);
DEPRECATED rs_bool PV_DECL pl_buf_get_size(int16 hbuf, int32* buf_size);
DEPRECATED rs_bool PV_DECL pl_buf_free(int16 hbuf);
DEPRECATED rs_bool PV_DECL pl_buf_get_bits(int16 hbuf, int16* bit_depth);
DEPRECATED rs_bool PV_DECL pl_exp_unravel(int16 hcam, uns16 exposure,
                                          void* pixel_stream, uns16 rgn_total,
                                          const rgn_type* rgn_array,
                                          uns16** array_list);
DEPRECATED rs_bool PV_DECL pl_exp_wait_start_xfer(int16 hcam, uns32 tlimit);
DEPRECATED rs_bool PV_DECL pl_exp_wait_end_xfer(int16 hcam, uns32 tlimit);

DEPRECATED rs_bool PV_DECL pv_cam_get_ccs_mem(int16 hcam, uns16* size);
DEPRECATED rs_bool PV_DECL pv_cam_send_debug(int16 hcam, char* debug_str,
                                             uns16 reply_len, char* reply_str);
DEPRECATED rs_bool PV_DECL pv_cam_write_read(int16 hcam, uns8 c_class, uns16 write_bytes,
                                             uns8* write_array, uns8* read_array);
DEPRECATED rs_bool PV_DECL pv_dd_active(int16 hcam, void* pixel_stream);
DEPRECATED rs_bool PV_DECL pv_exp_get_bytes(int16 hcam, uns32* exp_bytes);
DEPRECATED rs_bool PV_DECL pv_exp_get_script(int16 hcam, rs_bool* script_valid);
DEPRECATED rs_bool PV_DECL pv_exp_get_status(int16 hcam, int16* status,
                                             uns32* byte_cnt, uns32* frame_cnt);
DEPRECATED rs_bool PV_DECL pv_exp_set_bytes(int16 hcam, uns32 frame_count,
                                            uns32 seq_bytes, void* pixel_stream);
DEPRECATED rs_bool PV_DECL pv_exp_set_script(int16 hcam, rs_bool script_valid);
DEPRECATED rs_bool PV_DECL pv_set_error_code(int16 omode,int16 err_code);
DEPRECATED rs_bool PV_DECL pv_cam_do_reads(int16 hcam);
DEPRECATED rs_bool PV_DECL pv_free(void* block, int16 heap);
DEPRECATED void*   PV_DECL pv_malloc(uns32 size, int16 heap);
DEPRECATED void*   PV_DECL pv_realloc(void* block, uns32 size, int16 heap);
DEPRECATED rs_bool PV_DECL pv_script_set_hook(pm_script_hook* pfn);
DEPRECATED rs_bool PV_DECL pv_ccd_get_accum_capable(int16 hcam, rs_bool* accum_capable);
DEPRECATED rs_bool PV_DECL pv_exp_get_frames(int16 hcam, uns32* exp_frames);
DEPRECATED rs_bool PV_DECL pv_exp_set_frames(int16 hcam, uns32 exp_frames);
DEPRECATED rs_bool PV_DECL pv_exp_set_no_readout_timeout(int16 hcam);
DEPRECATED rs_bool PV_DECL pv_exp_reset_no_readout_timeout(int16 hcam);
DEPRECATED rs_bool PV_DECL pm_cam_write_read(int16 hcam, uns8 c_class, uns16 write_bytes,
                                             uns8* write_array, uns8* read_array);

DEPRECATED rs_bool PV_DECL pl_ddi_get_ver(uns16* ddi_version);
DEPRECATED rs_bool PV_DECL pl_cam_get_diags(int16 hcam);
 /* grp_pm_deprecated_functions */

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                         Frame metadata functions                          */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

rs_bool PV_DECL pl_md_frame_decode(md_frame* pDstFrame, void* pSrcBuf, uns32 srcBufSize);

rs_bool PV_DECL pl_md_frame_recompose(void* pDstBuf, uns16 offX, uns16 offY,
                                      uns16 dstWidth, uns16 dstHeight,
                                      md_frame* pSrcFrame);

rs_bool PV_DECL pl_md_create_frame_struct_cont(md_frame** pFrame, uns16 roiCount);

rs_bool PV_DECL pl_md_create_frame_struct(md_frame** pFrame, void* pSrcBuf,
                                          uns32 srcBufSize);

rs_bool PV_DECL pl_md_release_frame_struct(md_frame* pFrame);

rs_bool PV_DECL pl_md_read_extended(md_ext_item_collection* pOutput, void* pExtMdPtr,
                                    uns32 extMdSize);
 /* grp_pm_functions */

#ifdef PV_C_PLUS_PLUS
};
#endif

#endif /* PV_EMBEDDED */

/******************************************************************************/
/* End of function prototypes.                                                */
/******************************************************************************/

#endif /* _PVCAM_H */