#include <WinDNS.h>

#ifndef VADAVINTF_H_INCLUDED
#define VADAVINTF_H_INCLUDED

	////// acquisition //////
	#ifdef NUM_UNSIGNED // use unsigned tVD_Nums
	#define tVD_Num  unsigned short
	#else // use signed tVCA_Nums
	#define tVD_Num  short
	#endif

  #pragma pack (4)
  // acquisition flags tVDACQ_CallBackRec.rFlags
  #define cVDACQ_FDark         0	  // acquire dark frame
  #define cVDACQ_FBright       1      // acquire bright frame (dark otherwise)
  #define cVDACQ_FTestPat      2      // acquire test pattern  (TFT only)
  #define cVDACQ_FRecentFrame  4      // retrieve recent frame (TFT only)
  #define cVDACQ_FBrightIgn   (1<<31) // ignore state of the bit 'Bright' for machine control (affects some TFT only)
  // acquisition event types tVDACQ_CallBackRec.rType
  #define cVDACQ_ETTrace       0      // various information messages (mainly from acquistion thread<s>)
  #define cVDACQ_ETTraceT      1      // time-stamp and the information message
  #define cVDACQ_ETErr         2      // an error from the library's acquisition code
  #define cVDACQ_ETLastErr     3      // an error from Windows API, described by 'GetLastError'
  #define cVDACQ_ETWSAErr      4      // an error from Windows socket 
  // acquisition events tVDACQ_CallBackRec.rEvent
  #define cVDACQ_EAbort        1      // application invokes VDACQ_Abort
  #define cVDACQ_EClose        2      // application invokes VDACQ_Close
  #define cVDACQ_ECapture      20     // a message from the library's acquisition thread<s>
  #define cVDACQ_ECapturePerc  21     // acquisition thread<s> tells percentage of completeness
  #define cVDACQ_ECaptureRecv  22     // acquisition thread<s> informs about new received data
  #define cVDACQ_EIdle         23     // acquisition thread tells that it have had idle time-slice

  #define cVDACQ_EReadoutDone         24
  #define cVDACQ_EExposureDone        25

  #define cVDACQ_EAT_Ready		14
  #define cVDACQ_EAT_Wait		26
  #define cVDACQ_ECaptureFrame	30

  #define cVDACQ_EStandardMode_Change		31	// Standard mode change start, using with cVDACQ_ETTraceT or cVDACQ_ETErr
  #define cVDACQ_EStandardMode_Done		32	// Standard mode change done

  #define cVDACQ_ERecordStop	41 // VDACQ_Record(FALSE)
  #define cVDACQ_ERecordStart	42 // VDACQ_Record(TRUE)
  #define cVDACQ_EReplay		45 // VDACQ_Replay
  #define cVDACQ_ELostFrameIndex	49 // VDACQ_GetLostFrameIndex

  #define cVDACQ_EMultiCalHandler_Init		51 // cVDACQ_FGC_MultiCalHandler
  #define cVDACQ_EMultiCalHandler_Change	52 // cVDACQ_FGC_MultiCalHandler

  #define cVDACQ_ECapture2_CalHandlerInit	61 // cVDACQ_FGC_CaptureCalHandler
  #define cVDACQ_ECapture2_Expose			62 // VDACQ_Capture2
  #define cVDACQ_ECapture2_Receive			63 // acquisition thread informs about "capture(one-shot) on dynamic"

  // acquisition events tVDACQ_CallBackRec.rStatus (=rSocket)
  #define cVDACQ_ESStart		1
  #define cVDACQ_ESGeneral		2
  #define cVDACQ_ESDone			3
  #define cVDACQ_ESWarning		4
  #define cVDACQ_ESError		5
  #define cVDACQ_ESException	6
  #define cVDACQ_ESStop			7

  // framegrabber acquisition control flags tVDACQ_CallBackRec.rFGControl
  #define cVDACQ_FFGCStop      (1<<0) // FG control: stop acquisition
  #define cVDACQ_FFGCXOn       (1<<1) // FG control: XRay is 'On' 
                                      // keep this frame or add it to result when FGC_NoAve is OFF
//information feedback record
typedef struct CallBackRec{
	int rCode,
		rAborted;
	void *rUserCallBackProc,
		*rUserParam;
	HANDLE rThread = INVALID_HANDLE_VALUE;
	TCHAR rMsg[256];
} tVD_CallBackRec;

//information callback procedure
  typedef void(_stdcall *tVD_CallBackProc)(int, TCHAR *);

  // acquisition feedback record   
  typedef struct {
    int    rFlags,             // combination of cVDACQ_Fxxxx
           rType,              // cVDACQ_ETxxx
           rEvent;             // cVDACQ_Exxx
	union {
	int	   rSocket;            // 0:no relation to a 'socket'; otherwise socket's ID>0 (event's source ID) 
	int	   rStatus;            // cVDACQ_ESxxx; detailed status for each event
	};
    TCHAR  rMsg[256];          // message (trace, wrn, err)
    int    rFrameWidth,        // full frame width
           rFrameHeight;       // full frame height
	tVD_Num *rFrameBuffer;       // user supplied frame buffer "AFrameBuffer"
    union {
    int    rCaptureRows;       // # of received rows (for single frame acquisition)
    int    rCaptureFrames;     // # of received full frames (for framegrabber)
    };
    int    rCapturePercent;    // received data in percents
    void  *rUserCallBackProc,  // user supplied "ACallBackProc"
          *rUserParam;         // user supplied "AUserParam"
    int    rAborted;           // 0:none, 1:VDACQ_Abort, -1:internally
    void  *rPacketData;        // pointer to received packet; usually it is nil  
    int    rFGControl;         // frame-grabber's control flags
	int    rStandardMode;	   // Standard mode, defined depending on each model
  } tVDACQ_CallBackRec;
    // 'socket' ID  #1: control-send (respective thread or real socket for Ethernet)
    //              #2: control-receive
    //              #3: data-receive
    // When callback is triggered by received message from detector it has non-nil field
    // PacketData. Normally an OEM application does not check received packets directly.
    
  // callback procedure  
  typedef void (_stdcall *tVDACQ_CallBackProc)( tVDACQ_CallBackRec* );

  // framegrabber parameters for 'VDACQ_SetFGRec', 'VDACQ_GetFGRec'
  #define cVDACQ_FG_None     0        // use default acquisition (via Ethernet)
  #define cVDACQ_FG_NIIMAQ   1        // Nat Instr IMAQ
  #define cVDACQ_FG_AnyGrab  2        // VATech AnyGrabber
  #define cVDACQ_FG_FRM      3        // FRM11, FRM10 or FRM24 of DAQ systems
  #define cVDACQ_FG_FRM11    3        // for legacy SW compatibility
  #define cVDACQ_GigE_Vision 4        // GigE Vision
  #define cVDACQ_FG_CTT      4        // Contact-Us
  #define cVDACQ_FG_Et       5        // Ethernet 'default'
  #define cVDACQ_FG_OPT      6        // OPT01 of DAQ systems
  #define cVDACQ_Ethernet	 7        // Ethernet
  #define cVDACQ_FG_FX3		 8
  #define cVDACQ_FGC_NoUIXOn (1<<0)   // disable UI XOn controls (when UI is used)
  #define cVDACQ_FGC_NoAve   (1<<1)   // disable calculation of the average frame
  #define cVDACQ_FGC_NoDesp  (1<<2)   // use simple median 3x3 when VDC_FDespeckle is set
  #define cVDACQ_FGC_StandardMode  (1<<3)   // use standard mode
  #define cVDACQ_FGC_MultiCalHandler  (1<<4)   // use standard mode
  #define cVDACQ_FGC_CaptureCalHandler (1<<5) // use capture (one-shot on dynamic)
  typedef struct {
    int    rType,              // one of VDACQ_FG_xxx 
           rFG_Control,        // combination of the flags 'VDACQ_FGC_xxx'
           rCalFlags,          // combination of the flags 'VDC_Fxxxx'
           rRingBufs;          // number of ring-buffers (0:continuous memory queue)
    TCHAR  rInterfaceName[60];
  } tVDACQ_FGRec;

  ////// calibration //////
  // calibration flags
  #define cVDC_FCalOffs      1        // apply offset/dark calibration
  #define cVDC_FCalGain      2        // apply gain/bright calibration
  #define cVDC_FBadPixMap    4        // request application of bad pixels map
  #define cVDC_FDespeckle    8        // apply despeckle
  #define cVDC_FOptDist     16        // apply optical distortion correction
  #define cVDC_FAuxLnRecal  32        // apply auxiliary lines re-calibration
  #define cVDACQ_FCaptureCal (1<<8) // capture or oneshot calibration 
  #define cVDC_FTempDirIP   (1<<31)   // save temporary images in default image direcotory  

  // calibration event types
  #define cVDC_ETTrace       0        // information message from calibration code
  #define cVDC_ETTraceT      1        // time-stamp and information message
  #define cVDC_ETErr         2        // an error from the library's calibration code 
  // calibration events
  #define cVDC_EAbort        1        // application invokes VDC_Abort
  #define cVDC_EClose        2        // application invokes VDC_Close
  #define cVDC_ECalib        20       // a message from the library's calibration code
  #define cVDC_ECalibPerc    21       // calibration code tells percentage of completeness
  // calibration feedback record   
  typedef struct {
    int    rFlags,             // combination of cVDC_Fxxxx
           rType,              // cVDC_ETxxx
           rEvent;             // cVDC_Exxx
    TCHAR  rMsg[256];          // message (trace, wrn, err)
    int    rFrameWidth,        // full frame width
           rFrameHeight,       // full frame height
           rStoredWidth,       // stored image width
           rStoredHeight,      // stored image height
           rCalibPercent;      // amount of processed data in %
	tVD_Num *rFrameBuffer,       // received frame data
          *rImageBuffer;       // cropped image
    void  *rUserCallBackProc,  // user supplied "ACallBackProc"
          *rUserParam;         // user supplied "AUserParam"
    int    rAborted;           // 1: set by VDC_Abort; -1:internally
  } tVDC_CallBackRec;
  // callback procedure  
  typedef void (_stdcall *tVDC_CallBackProc)( tVDC_CallBackRec* );

  typedef struct {
    int  rImgCutLeft,          // cut left after rotation & flip 
         rImgCutTop,           // cut top after rotation & flip
         rImgCutRight,         // cut right after rotation & flip
         rImgCutBottom,        // cut bottom after rotation & flip
         rRotation,            // 0:none, 1:90 deg CCW, 2:90 deg CW
         rFlip;                // bit #0: flip horz, bit #1: flip vert 
  } tVDC_ImgCut;

  ///// image process /////
  // img process flags
  #define cVDIP_FDespeckle    1       // apply despeckle
  #define cVDIP_F3PCurve      2       // apply 3-points curve or simple inversion
  #define cVDIP_FUSMask       4       // apply all unsharpen filters
  // img process event types
  #define cVDIP_ETTrace       0       // information message from 'enhancement' code
  #define cVDIP_ETTraceT      1       // time-stamp and information message
  #define cVDIP_ETErr         2       // an error from the library's 'enhancement' code 
  // img process events
  #define cVDIP_EAbort        1       // application invokes VDIP_Abort 
  #define cVDIP_EClose        2       // application invokes VDIP_Close
  #define cVDIP_EEnh          20      // information message from 'enhancement' code
  #define cVDIP_EEnhPerc      21      // 'enhancement' code tells percentage of completeness
  // img process feedback record   
  typedef struct {
    int    rFlags,             // combination of cVDC_Fxxxx
           rType,              // cVDC_ETxxx
           rEvent;             // cVDC_Exxx
    TCHAR  rMsg[256];          // message (trace, wrn, err)
    int    rStoredWidth,       // stored image width
           rStoredHeight,      // stored image height
           rEnhPercent,        // processed data in %
           rModeNumber;        // img process mode
	tVD_Num *rImageBuffer;       // image buffer
    void  *rUserCallBackProc,  // user supplied "ACallBackProc"
          *rUserParam;         // user supplied "AUserParam"
    int    rAborted;           // 1: set by VDIP_Abort; -1:internally
  } tVDIP_CallBackRec;
  // callback procedure  
  typedef void (_stdcall *tVDIP_CallBackProc)( tVDIP_CallBackRec* );
  #pragma pack ()

#define DWORD_FLAG_MODE_COMMON				(DWORD)0x00
#define DWORD_FLAG_MODE_BINNING				(DWORD)0x01
#define DWORD_FLAG_MODE_PARTIALVALUE		(DWORD)0x02
#define DWORD_FLAG_MODE_FRAMERATE			(DWORD)0x04
#define DWORD_FLAG_MODE_SENSITIVITY			(DWORD)0x08
#define DWORD_FLAG_MODE_DYNAMICTRIGGER		(DWORD)0x10
#define DWORD_FLAG_MODE_ONESHOTTRIGGER		(DWORD)0x20
#define DWORD_FLAG_MODE_CAPTUREEXPOSURETIME	(DWORD)0x40
#define DWORD_FLAG_MODE_CAPTUREWAITTIME		(DWORD)0x80

#define DWORD_FLAG_CLOSING_NORMAL			(DWORD)0x00
#define DWORD_FLAG_CLOSING_TIMEOUT			(DWORD)0x01
#define DWORD_FLAG_CLOSING_INIT_FAULT		(DWORD)0x02

  typedef void(_stdcall* GetDetectorModeCallback)(DWORD, DWORD, const TCHAR*);

  #define cVD_IntParamNone 0x80000000  // for VD_IntParam

  #ifdef INTERNAL_VATECH_DAVINCI_LIBRARY // procedures' declarations ('as is' in the DLL)

    // general UI and logs //
    // returns TRUE if UNICODE version
    BOOL _stdcall VD_IsUnicode();
    // invokes general property sheet
    BOOL _stdcall VD_Dialog();
    // open log-file
    void _stdcall VD_LogOpen( const TCHAR *AHomeDir, int ANumLogFiles, const TCHAR *AFPrefix );
    // record string to log-file
    void _stdcall VD_LogMsg( const TCHAR *AMsg );
    // close log-file
    void _stdcall VD_LogClose();
    // flush log-file
    void _stdcall VD_LogFlush();
    // returns home directory
    void _stdcall VD_GetHomeDirectory( TCHAR *ADir );
    // set section name in library's initialization profile file
    void _stdcall VD_IniProfSetSection( const TCHAR *ASectName );
    // get string key from library's initialization profile
    const TCHAR* _stdcall VD_IniProfGetStr( const TCHAR *AKeyName, const TCHAR *ADefault );
    // set/get "data segment" (static) parameter
    int _stdcall VD_IntParam( const TCHAR *AParamName, int AParamValue );
    const TCHAR* _stdcall VD_StrParam( const TCHAR *AParamName, const TCHAR *AParamValue );

    ////// acquisition //////
    // sets full frame dimension (should not be called for real acquisitin case)
    void _stdcall VDACQ_SetFrameDim( int AWidth, int AHeight );
    // returns full frame dimension
    void _stdcall VDACQ_GetFrameDim( int *AWidth, int *AHeight );
    // connects to detector
    tVDACQ_CallBackRec* _stdcall VDACQ_Connect( int AFlags,
		tVDACQ_CallBackProc AUserCallBackProc, void *AUserParam, tVD_Num *AFrameBuffer, int AMode );
	void _stdcall rVDACQ_SetCaptureBuf(tVD_Num *AFrameBuffer);
    // send simple auxiliary command (TFT only)
    BOOL _stdcall VDACQ_SendCommand( tVDACQ_CallBackRec *ACallBackRec, DWORD ACommand );
    BOOL _stdcall VDACQ_SendCommandParam( tVDACQ_CallBackRec *ACallBackRec, DWORD ACommand, const void *AData, int ADataSize );
    // vendor comand (USB only)
    BOOL _stdcall VDACQ_VendorCommand( tVDACQ_CallBackRec *ACallBackRec, int ARequest, int AValue, int AIndex );
    // starts acquisition
    BOOL _stdcall VDACQ_StartFrame( tVDACQ_CallBackRec *ACallBackRec );
    // aborts acquisition
    BOOL _stdcall VDACQ_Abort( tVDACQ_CallBackRec *ACallBackRec );
    // releases resources associated with ACallBackRec
    void _stdcall VDACQ_Close( tVDACQ_CallBackRec *ACallBackRec );
	void _stdcall VDACQ_Resume(); 
	void _stdcall VDACQ_Stop();
	void _stdcall VDACQ_Capture(int nMode);
	void _stdcall VDACQ_Capture2(tVDACQ_CallBackRec *ACallBackRec);
	void _stdcall VDC_CalDir(int nNum);

    // returns current detector's IP or PID
    void _stdcall VDACQ_GetDetectorAddr( TCHAR *AIPAddr );
    // sets detector's IP or PID
    void _stdcall VDACQ_SetDetectorAddr( const TCHAR *AAddr );
    // sets framegrabber's parameters
    void _stdcall VDACQ_SetFGRec( const tVDACQ_FGRec *AFGRec );
    // returns framegrabber's parameters
    void _stdcall VDACQ_GetFGRec( tVDACQ_FGRec *AFGRec );
    // returns current number of acquired frames at low-level
    int _stdcall VDACQ_GetFGFrameNum();
    // sets freeze state for framegrabber; AFreezeState<0 just returns current state
    int _stdcall VDACQ_FGFreeze( int AFreezeState );
    // set detector's information to flash memory (as ASCII)
    BOOL _stdcall VDACQ_GetDetectorInfo( TCHAR *AStr );
    // retrieve detector's information from flash memory (as ASCII)
    BOOL _stdcall VDACQ_SetDetectorInfo( const TCHAR *AStr );
	// returns Detector FPGA version
	bool _stdcall VDACQ_GetVersionFPGA(TCHAR* Aversion);
	// returns Detector MCU version
	bool _stdcall VDACQ_GetVersionMCU(TCHAR* Aversion);
	// returns Detector Serial number
	bool _stdcall VDACQ_GetSerialNumber(TCHAR* Aserialnum);
	// returns Detector Model name
	bool _stdcall VDACQ_GetModelName(TCHAR* Amodelname);
	// returns Detector current state
	bool _stdcall VDACQ_GetDetectorState(int* Aresult);
    
    ////// calibration //////
    // returns image dimension; returns FALSE if all cut margins are zero
    BOOL _stdcall VDC_GetImageDim( int *AWidth, int *AHeight );
    // cuts (also rotates and flips optionally) frame buffer to image's dimension.
	tVD_Num *_stdcall VDC_CutImage( const tVD_Num *AFrameBuffer, tVD_Num *AImageBuffer );
	tVD_Num *_stdcall VDC_ROIImage( const tVD_Num *AFrameBuffer, tVD_Num *AImageBuffer, int ATargetX, int ATargetY, int ATargetWidth, int ATargetHeight );
    // starts calibration
    tVDC_CallBackRec* _stdcall VDC_Process( int AFlags,
		tVDC_CallBackProc AUserCallBackProc, void *AUserParam, tVD_Num *AFrameBuffer );
	tVDC_CallBackRec* _stdcall VDC_Process_OneShot( int AFlags,
		tVDC_CallBackProc AUserCallBackProc, void *AUserParam, tVD_Num *AFrameBuffer );
    // aborts calibration
    BOOL _stdcall VDC_Abort( tVDC_CallBackRec *ACallBackRec );
    // releases resources associated with ACallBackRec
    void _stdcall VDC_Close( tVDC_CallBackRec *ACallBackRec );
    // service: returns current calibration directory
    void _stdcall VDC_GetCalibrationDirectory( TCHAR *ADir );
    // service: set temporary calibration directory
    BOOL _stdcall VDC_SetCalibrationDirectory( const TCHAR *ADir );
    // service: returns image cut params
    void _stdcall VDC_GetImgCutParams( tVDC_ImgCut *ACutParams );
    // service: sets image cut params
    void _stdcall VDC_SetImgCutParams( const tVDC_ImgCut *ACutParams );
	void _stdcall VDC_SetDigitalGain( double nGain );
	double _stdcall VDC_GetDigitalGain();
    
    ///// image process /////
    // starts img process 
    tVDIP_CallBackRec* _stdcall VDIP_Process( int AFlags,
		tVDIP_CallBackProc AUserCallBackProc, void *AUserParam, tVD_Num *AImageBuffer, int AModeNumber );
    // aborts img process 
    BOOL _stdcall VDIP_Abort( tVDIP_CallBackRec *ACallBackRec );
    // releases resources associated with ACallBackRec
    void _stdcall VDIP_Close( tVDIP_CallBackRec *ACallBackRec );

    //// user interface /////
	void _stdcall VD_Set_Acquisition( int AFlags, tVD_Num *AFrameData, int AMode, tVDACQ_CallBackProc AUserCallBackProc, void *AUserParam );
	void _stdcall VD_Set_Calibration( int AFlags, tVD_Num *AFrameData, tVD_Num *AImgData, tVDC_CallBackProc AUserCallBackProc, void *AUserParam );
	void _stdcall VD_Set_ImgProcess( int AFlags, tVD_Num *AImgData, int AModeNumber, tVDIP_CallBackProc AUserCallBackProc, void *AUserParam );
    // default modal dialog with preview
    int _stdcall VD_GetImage( HWND AOwner );
    // modal dialog with preview in specified rectangle
    int _stdcall VD_GetImageSP( HWND AOwner, int AWndLeft, int AWndTop, int AWndWidth, int AWndHeight );
    // modal dialog withoiut preview
    int _stdcall VD_GetImageA( HWND AOwner, int AWndLeft, int AWndTop );
    // cancel modal dialog
    void _stdcall VD_GetImageCancel();
	BOOL _stdcall VD_GetDark(int nFrameNum, int nSkip, int nTimeout, BOOL bDataSeires);
	BOOL _stdcall VD_GetDark_Forced(int nFrameNum, int nSkip, int nTimeout, BOOL bDataSeires);
	BOOL _stdcall VD_GetBright(int nFrameNum, int nSkip, int nTimeout, BOOL bDataSeires);
	int _stdcall VD_GetBright2(int nFrameNum, int nSkip, int nTimeout, BOOL bDataSeires);
	BOOL _stdcall VD_Grab(tVD_Num *pImage, int nCalFlag, int nFrameNum, int nSkip, int nTimeout, BOOL bDataSeires);
	BOOL _stdcall VD_CheckInterface(int nTimeout);
	void _stdcall VD_GigE_Init();
	BOOL _stdcall VDC_GenerateBright();
	BOOL _stdcall VDC_GenerateBPM();
	void _stdcall VDC_NoiseReduction(unsigned short *pInputData, int nWidth, int nHeight, float nPara1, int nPara2);
	
	int CalGO_GetIntFromStr( const TCHAR *AStr, int APos, int ALen );

	BOOL _stdcall VDACQ_SetBinning( int nBinning );
	BOOL _stdcall VDACQ_SetFrameRate( float nFrameRate );
	BOOL _stdcall VDACQ_SetSensitivity( int nSensitivity );
	BOOL _stdcall VDACQ_SetPartialValue(int nValue);
	BOOL _stdcall VDACQ_SetRFMode(int nValue);
	BOOL _stdcall VDACQ_SetOneShot( int nOneShotMode );
	BOOL _stdcall VDACQ_SetDynamic_Trigger( int nDynamicTriggerMode );
	BOOL _stdcall VDACQ_SetOneShot_Trigger(int nOneShotTriggerMode);
	void _stdcall VDC_SetRecursiveFilter( int bEnable );

	int _stdcall VDACQ_GetBinning();
	double _stdcall VDACQ_GetFrameRate();
	int _stdcall VDACQ_GetSensitivity();
	int _stdcall VDACQ_GetPartialValue();
	int _stdcall VDACQ_GetRFMode();
	BOOL _stdcall VDACQ_GetOneShot();
	int _stdcall VDACQ_GetDynamic_Trigger();
	int _stdcall VDACQ_GetOneShot_Trigger();
	BOOL _stdcall VDC_GetRecursiveFilter();

	BOOL _stdcall VD_FreeResource();
	BOOL _stdcall VDC_GenerateBright();
	void _stdcall VD_IniSave();
	BOOL _stdcall VDACQ_SecondCtrl();
    BOOL _stdcall VDACQ_ModeLock(BOOL bLock);
    BOOL _stdcall VD_GetDetectorMode(DWORD dwFlags, GetDetectorModeCallback pCallbackproc);
    DWORD _stdcall VD_GetLastError();
    int _stdcall VDACQ_GetCaptureExposureTime();
    BOOL _stdcall VDACQ_SetCaptureExposureTime(int);
	int _stdcall VDACQ_GetCaptureWaitTime();
    BOOL _stdcall VDACQ_SetCaptureWaitTime(int);
	tVD_CallBackRec* _stdcall VD_IntgTimeCalibration(tVD_CallBackProc AUserCallBackProc);
	BOOL _stdcall VD_GenerateBPM(tVD_CallBackProc);
	BOOL _stdcall VDACQ_DarkReloadInAcquisition(tVDACQ_CallBackRec*);
	QWORD _stdcall VD_GetVersionVADAV();
	QWORD _stdcall VD_GetVersionVACAL();
	QWORD _stdcall VD_GetVersionView16();
	BOOL _stdcall VDACQ_SetDynExposureTime(float);
	BOOL _stdcall VDAUX_IsAbleStretch();
	BOOL _stdcall VDAUX_SetStretch(int srcW, int srcH, float dstPX, float dstPY);
	BOOL _stdcall VDAUX_GetStretchDim(int* dstW, int* dstH);
	BOOL _stdcall VDAUX_DoStretch(const unsigned short* src, unsigned short* dst);
	BOOL _stdcall VDACQ_IsAbleStandardMode();
	BOOL _stdcall VDACQ_InitStandardMode(int nFlag);
	BOOL _stdcall VDACQ_SetStandardMode(int nMode, tVDACQ_CallBackRec *ACallBackRec);
	BOOL _stdcall VDACQ_IsAbleReplay();
	BOOL _stdcall VDACQ_Record(BOOL bStart);
	BOOL _stdcall VDACQ_Replay(int nStartIndex, int nFrameCount);
	int _stdcall VDACQ_GetLostFrameIndex(int nCount, unsigned short *pIndex);
	BOOL _stdcall VDACQ_SetMultiCalHandler(int nHandlerNum);
#else // for use in applications

    // table of exported methods
    typedef struct {
      HINSTANCE rHDLL; // the library's handle
      // general UI and logs //
      BOOL (_stdcall *rVD_IsUnicode)(void);
      BOOL (_stdcall *rVD_Dialog)( HWND ); // it has additional parameter: owner's window
      void (_stdcall *rVD_LogOpen)( const TCHAR*, int, const TCHAR* );
      void (_stdcall *rVD_LogMsg)( const TCHAR* );
      void (_stdcall *rVD_LogClose)(void);
      void (_stdcall *rVD_LogFlush)(void);
      void (_stdcall *rVD_GetHomeDirectory)( TCHAR* );
      void (_stdcall *rVD_IniProfSetSection)( const TCHAR* );
      const TCHAR* (_stdcall *rVD_IniProfGetStr)( const TCHAR*, const TCHAR* );
      int (_stdcall *rVD_IntParam)( const TCHAR*, int );
      const TCHAR* (_stdcall *rVD_StrParam)( const TCHAR*, const TCHAR* );

      ////// acquisition //////
      void (_stdcall *rVDACQ_SetFrameDim)( int, int );
      void (_stdcall *rVDACQ_GetFrameDim)( int*, int* );
	  tVDACQ_CallBackRec* (_stdcall *rVDACQ_Connect)(int, tVDACQ_CallBackProc, void*, tVD_Num*, int);
	  void(_stdcall *rVDACQ_SetCaptureBuf)(tVD_Num *);
      BOOL (_stdcall *rVDACQ_SendCommand)( tVDACQ_CallBackRec*, DWORD );
      BOOL (_stdcall *rVDACQ_SendCommandParam)( tVDACQ_CallBackRec*, DWORD, const void*, int );
      BOOL (_stdcall *rVDACQ_StartFrame)( tVDACQ_CallBackRec* );
      BOOL (_stdcall *rVDACQ_VendorCommand)( tVDACQ_CallBackRec*, int, int, int );
      BOOL (_stdcall *rVDACQ_Abort)( tVDACQ_CallBackRec* );
      void (_stdcall *rVDACQ_Close)( tVDACQ_CallBackRec* );
	  void (_stdcall *rVDACQ_Stop)( );
	  void (_stdcall *rVDACQ_Resume)( );
	  void (_stdcall *rVDACQ_Capture)(int nMode );
	  void (_stdcall *rVDACQ_Capture2)(tVDACQ_CallBackRec *ACallBackRec);
      void (_stdcall *rVDACQ_GetDetectorAddr)( TCHAR* );
      void (_stdcall *rVDACQ_SetDetectorAddr)( const TCHAR* );
      void (_stdcall *rVDACQ_SetFGRec)( const tVDACQ_FGRec*);
      void (_stdcall *rVDACQ_GetFGRec)( tVDACQ_FGRec* );
      int  (_stdcall *rVDACQ_GetFGFrameNum)(void);
      int  (_stdcall *rVDACQ_FGFreeze)( int );
      BOOL (_stdcall *rVDACQ_GetDetectorInfo)( TCHAR* );
      BOOL (_stdcall *rVDACQ_SetDetectorInfo)( const TCHAR* );
	  bool(_stdcall *rVDACQ_GetVersionFPGA)(TCHAR*);
	  bool(_stdcall *rVDACQ_GetVersionMCU)(TCHAR*);
	  bool(_stdcall *rVDACQ_GetSerialNumber)(TCHAR*);
	  bool(_stdcall *rVDACQ_GetModelName)(TCHAR*);
	  bool(_stdcall *rVDACQ_GetDetectorState)(int*);
      ////// calibration //////
      BOOL (_stdcall *rVDC_GetImageDim)( int*, int* );
	  tVD_Num* (_stdcall *rVDC_CutImage)(const tVD_Num*, tVD_Num*);
	  tVD_Num* (_stdcall *rVDC_ROIImage)(const tVD_Num*, tVD_Num*, int, int, int, int);
	  tVDC_CallBackRec* (_stdcall *rVDC_Process)(int, tVDC_CallBackProc, void*, tVD_Num*);
      BOOL (_stdcall *rVDC_Abort)( tVDC_CallBackRec* );
      void (_stdcall *rVDC_Close)( tVDC_CallBackRec* );
      void (_stdcall *rVDC_GetCalibrationDirectory)( TCHAR* );
      BOOL (_stdcall *rVDC_SetCalibrationDirectory)( const TCHAR* );
      void (_stdcall *rVDC_GetImgCutParams)( tVDC_ImgCut* );
      void (_stdcall *rVDC_SetImgCutParams)( const tVDC_ImgCut* );
	  void (_stdcall *rVDC_SetDigitalGain)( double );
	  double (_stdcall *rVDC_GetDigitalGain)( );
      ///// image process /////
	  tVDIP_CallBackRec* (_stdcall *rVDIP_Process)(int, tVDIP_CallBackProc, void*, tVD_Num*, int);
      BOOL (_stdcall *rVDIP_Abort)( tVDIP_CallBackRec* );
      void (_stdcall *rVDIP_Close)( tVDIP_CallBackRec* );
      //// user interface /////
	  void(_stdcall *rVD_Set_Acquisition)(int, tVD_Num*, int, tVDACQ_CallBackProc, void*);
	  void(_stdcall *rVD_Set_Calibration)(int, tVD_Num*, tVD_Num*, tVDC_CallBackProc, void*);
	  void(_stdcall *rVD_Set_ImgProcess)(int, tVD_Num*, int, tVDIP_CallBackProc, void*);
      int (_stdcall *rVD_GetImage)( HWND );
      int (_stdcall *rVD_GetImageSP)( HWND, int, int, int, int );
      int (_stdcall *rVD_GetImageA)( HWND, int, int );
      void (_stdcall *rVD_GetImageCancel)(void);
	  BOOL (_stdcall *rVD_GetDark)(int, int, int, BOOL);
	  BOOL (_stdcall *rVD_GetDark_Forced)(int, int, int, BOOL);
	  BOOL (_stdcall *rVD_GetBright)(int, int, int, BOOL);
	  int (_stdcall *rVD_GetBright2)(int, int, int, BOOL);
	  BOOL(_stdcall *rVD_Grab)(tVD_Num *, int, int, int, int, BOOL);
      BOOL (_stdcall *rVD_CheckInterface) (int );
	  void (_stdcall *rVD_GigE_Init)( void );
	  BOOL (_stdcall *rVDC_GenerateBright)( );
	  BOOL (_stdcall *rVDC_GenerateBPM)( );
	  void (_stdcall *rVDC_NoiseReduction)(unsigned short *, int, int, float, int);

	  BOOL (_stdcall *rVDACQ_SetRFMode)( int nValue );
	  BOOL (_stdcall *rVDACQ_SetBinning)( int nBinning );
	  BOOL	(_stdcall *rVDACQ_SetPartialValue)( int nValue );
	  BOOL (_stdcall *rVDACQ_SetFrameRate)( float nFrameRate );
	  BOOL (_stdcall *rVDACQ_SetSensitivity)( int nSensitivity );
	  BOOL (_stdcall *rVDACQ_SetOneShot)( int nOneShotMode );
	  BOOL (_stdcall *rVDACQ_SetDynamic_Trigger)( int nDynamicTriggerMode );
	  BOOL (_stdcall *rVDACQ_SetOneShot_Trigger)( int nOneShotTriggerMode );
	  void (_stdcall *rVDC_SetRecursiveFilter)( int bEnable );

	  int (_stdcall *rVDACQ_GetBinning)();
	  double (_stdcall *rVDACQ_GetFrameRate)();
	  int (_stdcall *rVDACQ_GetSensitivity)();
	  int (_stdcall *rVDACQ_GetPartialValue)();
	  int (_stdcall *rVDACQ_GetRFMode)();
	  BOOL (_stdcall *rVDACQ_GetOneShot)();
	  int (_stdcall *rVDACQ_GetDynamic_Trigger)();
	  int (_stdcall *rVDACQ_GetOneShot_Trigger)();
	  BOOL (_stdcall *rVDC_GetRecursiveFilter)();

	  BOOL (_stdcall *rVD_FreeResource)( );
	  void (_stdcall *rVD_RegisterCallbackInfo)(tVD_CallBackProc );
	  void (_stdcall *rVDC_CalDir)( int nNum );

	  void (_stdcall *rVD_IniSave)();
	  BOOL (_stdcall *rVDACQ_SecondCtrl)();
	  BOOL (_stdcall *rVDACQ_ModeLock)(BOOL);
	  BOOL (_stdcall *rVD_GetDetectorMode)(DWORD, GetDetectorModeCallback);
	  DWORD (_stdcall *rVD_GetLastError)();

      int (_stdcall *rVDACQ_GetCaptureExposureTime)();
      BOOL (_stdcall *rVDACQ_SetCaptureExposureTime)(int);
      int (_stdcall *rVDACQ_GetCaptureWaitTime)();
      BOOL (_stdcall *rVDACQ_SetCaptureWaitTime)(int);
      tVD_CallBackRec* (_stdcall *rVD_IntgTimeCalibration)(tVD_CallBackProc);
      BOOL (_stdcall* rVD_GenerateBPM)(tVD_CallBackProc);
      BOOL(_stdcall* rVDACQ_DarkReloadInAcquisition)(tVDACQ_CallBackRec*);
      QWORD(_stdcall* rVD_GetVersionVADAV)();
      QWORD(_stdcall* rVD_GetVersionVACAL)();
      QWORD(_stdcall* rVD_GetVersionView16)();
	  BOOL(_stdcall* rVDACQ_SetDynExposureTime)(float);
	  BOOL (_stdcall* rVDAUX_IsAbleStretch)();
	  BOOL (_stdcall* rVDAUX_SetStretch)(int srcW, int srcH, float dstPX, float dstPY);
	  BOOL (_stdcall* rVDAUX_GetStretchDim)(int* dstW, int* dstH);
	  BOOL (_stdcall* rVDAUX_DoStretch)(const unsigned short* src, unsigned short* dst);
	  BOOL(_stdcall* rVDACQ_IsAbleStandardMode)();
	  BOOL(_stdcall* rVDACQ_InitStandardMode)(int nFlag);
	  BOOL (_stdcall* rVDACQ_SetStandardMode)(int nMode, tVDACQ_CallBackRec *ACallBackRec);
	  BOOL (_stdcall* rVDACQ_IsAbleReplay)();
	  BOOL (_stdcall* rVDACQ_Record)(int nStart, tVDACQ_CallBackRec *ACallBackRec);
	  BOOL (_stdcall* rVDACQ_Replay)(int nStartIndex, int nFrameCount, tVDACQ_CallBackRec *ACallBackRec);
	  int (_stdcall* rVDACQ_GetLostFrameIndex)(int nCount, unsigned short *pIndex);
	  BOOL (_stdcall* rVDACQ_SetMultiCalHandler)(int nHandlerNum);
} tVADAV_InterfaceRec;

    BOOL VADAV_MapDLL( const TCHAR *ADllFName, tVADAV_InterfaceRec *AIntfRec );
    // calls LoadLibrary and fills "AIntfRec"
    void VADAV_ReleaseDLL( tVADAV_InterfaceRec *AIntfRec );
    // calls FreeLibrary

  #endif // for use in applications
#endif // ifdef VADAVINTF_H_INCLUDED