handleaiuinew/env/Dalsa/include/SapTransfer.h

#ifndef _SAPTRANSFER_H_
#define _SAPTRANSFER_H_

//	SapTransfer.h : header file
//

#include "SapClassBasicDef.h"

// Forward declarations
class SAPCLASSBASIC_CLASS SapXferContextInfo;
class SAPCLASSBASIC_CLASS SapTransfer;
class SAPCLASSBASIC_CLASS SapXferCallbackInfo;
#if !SAPERA_DOT_NET
class SAPCLASSBASIC_CLASS SapXferMultiNode;
#endif

typedef void (*SapXferCallback)(SapXferCallbackInfo *);

//
// SapXferPair class declaration
//
class SAPCLASSBASIC_CLASS SapXferPair
{
public:
   // Transfer event types
   typedef int EventType;     // For compatibility with old Sapera++ application code
   enum _EventType
   {
      EventNone          = 0,
      EventStartOfField  = CORXFER_VAL_EVENT_TYPE_START_OF_FIELD,
      EventStartOfOdd    = CORXFER_VAL_EVENT_TYPE_START_OF_ODD,
      EventStartOfEven   = CORXFER_VAL_EVENT_TYPE_START_OF_EVEN,
      EventStartOfFrame  = CORXFER_VAL_EVENT_TYPE_START_OF_FRAME,
      EventEndOfField    = CORXFER_VAL_EVENT_TYPE_END_OF_FIELD,
      EventEndOfOdd      = CORXFER_VAL_EVENT_TYPE_END_OF_ODD,
      EventEndOfEven     = CORXFER_VAL_EVENT_TYPE_END_OF_EVEN,
      EventEndOfFrame    = CORXFER_VAL_EVENT_TYPE_END_OF_FRAME,
      EventEndOfLine     = CORXFER_VAL_EVENT_TYPE_END_OF_LINE,
      EventEndOfNLines   = CORXFER_VAL_EVENT_TYPE_END_OF_NLINES,
      EventEndOfTransfer = CORXFER_VAL_EVENT_TYPE_END_OF_TRANSFER,
      EventLineUnderrun  = CORXFER_VAL_EVENT_TYPE_LINE_UNDERRUN,
      EventFieldUnderrun = CORXFER_VAL_EVENT_TYPE_FIELD_UNDERRUN,
      EventMask          = CORXFER_VAL_EVENT_TYPE_MASK
   };

   // Transfer cycle modes
   typedef int CycleMode;
   enum _CycleMode
   {
      CycleUnknown       = -1,
      CycleAsynchronous  = CORXFER_VAL_CYCLE_MODE_ASYNCHRONOUS,
      CycleSynchronous   = CORXFER_VAL_CYCLE_MODE_SYNCHRONOUS,
      CycleWithTrash     = CORXFER_VAL_CYCLE_MODE_SYNCHRONOUS_WITH_TRASH,
      CycleOff           = CORXFER_VAL_CYCLE_MODE_OFF,
      CycleNextEmpty     = CORXFER_VAL_CYCLE_MODE_NEXT_EMPTY,
      CycleNextWithTrash = CORXFER_VAL_CYCLE_MODE_SYNCHRONOUS_NEXT_EMPTY_WITH_TRASH
   };

   //Xfer element
   typedef int XferElement;
   enum _XferElement
   {
      ElementPair    = CORXFER_VAL_ELEMENT_PAIR,
      ElementGroup   = CORXFER_VAL_ELEMENT_GROUP
   };

   // Flipping modes
   typedef int FlipMode;
   enum _FlipMode
   {
      FlipNone       = CORXFER_VAL_FLIP_OFF,
      FlipHorizontal = CORXFER_VAL_FLIP_HORZ,
      FlipVertical   = CORXFER_VAL_FLIP_VERT
   };

   // Event count source
   typedef int EventCountSource;
   enum _EventCountSource
   {
      EventCountNone = CORXFER_VAL_EVENT_COUNT_SOURCE_NONE,
      EventCountDst  = CORXFER_VAL_EVENT_COUNT_SOURCE_DST,
      EventCountSrc  = CORXFER_VAL_EVENT_COUNT_SOURCE_SRC
   };

   // Counter stamp time base
   typedef int CounterStampTimeBase;
   enum _CounterStampTimeBase
   {
      CounterStampMicroSec    = CORXFER_VAL_TIME_BASE_US,
      CounterStampMilliSec    = CORXFER_VAL_TIME_BASE_MS,
      CounterStampLine        = CORXFER_VAL_TIME_BASE_LINE,
      CounterStampLineTrigger = CORXFER_VAL_TIME_BASE_LINE_TRIGGER,
      CounterStampFrame       = CORXFER_VAL_TIME_BASE_FRAME,
      CounterStampExtFrameTrigger = CORXFER_VAL_TIME_BASE_EXT_FRAME_TRIGGER,
      CounterStampShaftEncoder = CORXFER_VAL_TIME_BASE_SHAFT_ENCODER
   };

   // Flat-field correction cycle modes
   typedef int FlatFieldCycleMode;
   enum _FlatFieldCycleMode
   {
      FlatFieldCycleOff       = CORXFER_VAL_FLATFIELD_CYCLE_MODE_OFF,
      FlatFieldCycleAutomatic = CORXFER_VAL_FLATFIELD_CYCLE_MODE_AUTOMATIC,
   };

   // Dynamic LUT cycle modes
   typedef int DynamicLutCycleMode;
   enum _DynamicLutCycleMode
   {
      DynamicLutCycleOff       = CORXFER_VAL_DYNAMIC_LUT_CYCLE_MODE_OFF,
      DynamicLutCycleAutomatic = CORXFER_VAL_DYNAMIC_LUT_CYCLE_MODE_AUTOMATIC,
      DynamicLutCycleManual    = CORXFER_VAL_DYNAMIC_LUT_CYCLE_MODE_MANUAL,
   };

   // Various constants
   enum MiscValues
   {
      InvalidFramesOnBoard = -1
   };

public:
   SapXferPair() 
      { Construct(NULL, 0, NULL, 0, FALSE); }

   SapXferPair(SapXferNode *pSrc, SapXferNode *pDst, BOOL regCallback = TRUE)
      { Construct(pSrc, 0, pDst, 0, regCallback); }

   SapXferPair(SapXferNode *pSrc, int srcPort, SapXferNode *pDst, int dstPort, BOOL regCallback = TRUE)
      { Construct(pSrc, srcPort, pDst, dstPort, regCallback); }

   ~SapXferPair() {}

   SapXferNode *GetSrc() const { return m_pSrc; } 
   int GetSrcPort()      const { return m_SrcPort; }
   int GetSrcIndex()     const { return m_SrcPort; }
   SapXferNode *GetDst() const { return m_pDst; }
   int GetDstPort()      const { return m_DstPort; }

   BOOL IsRegCallback()          const { return m_bRegCallback; }
   SapXferCallback GetCallback() const { return m_pCallback; }
   void *GetContext()            const { return m_pContext; }

   SapXferCallback GetTrashCallback() const { return m_pTrashCallback; }
   void *GetTrashContext()            const { return m_pTrashContext; }

	int GetFramesPerCallback()    const { return m_FramesPerCallback;}
	int GetFramesOnBoard()			const { return m_FramesOnBoard;}
	int GetRelativeBufferIndex()	const { return m_RelativeBufferIndex;}

   int GetNbInputFrames()   const { return m_NbInputFrames;}
   int GetNbOutputFrames()   const { return m_NbOutputFrames;}

   EventType GetEventType() const { return m_EventType; }
   EventCountSource GetEventCountSource() const { return m_EventCountSource; }
   
	CycleMode GetCycleMode() const 
	{ 
			CycleMode cycleMode= m_CycleMode;
		   if( cycleMode == SapXferPair::CycleUnknown && GetDst() != NULL)
			{
				// Determine default mode if none was set by the application
				cycleMode = SapXferPair::CycleAsynchronous;
				if ( GetDst()->GetTrash() != CORHANDLE_NULL)
					cycleMode = SapXferPair::CycleWithTrash;
			}

			return cycleMode; 
	}

   FlipMode GetFlipMode()   const 
		{ 	return m_FlipMode; }
   
	CounterStampTimeBase GetCounterStampTimeBase() const 
		{ 	return m_CounterStampTimeBase; }

   FlatFieldCycleMode GetFlatFieldCycleMode()   const 
		{ 	return m_FlatFieldCycleMode; }
   
   DynamicLutCycleMode GetDynamicLutCycleMode()   const 
		{ 	return m_DynamicLutCycleMode; }
   
   inline BOOL SetCallbackInfo(SapXferCallback pCallback, void *pContext);
	inline BOOL SetEventType(EventType eventType);
	inline BOOL SetEventCountSource(EventCountSource eventCountSource);
	inline BOOL SetCycleMode(CycleMode cycleMode);
	inline BOOL SetFlipMode(FlipMode flipMode);
	inline BOOL SetCounterStampTimeBase(CounterStampTimeBase counterStampTimeBase);
	inline BOOL SetFlatFieldCycleMode(FlatFieldCycleMode flatFieldCycleMode);
	inline BOOL SetDynamicLutCycleMode(DynamicLutCycleMode dynamicLutCycleMode);
	inline BOOL SetFramesPerCallback(int numFrames);
	inline BOOL SetFramesOnBoard( int numFrames);
	inline BOOL SetRelativeBufferIndex( int relativeBufferIndex);
	inline BOOL SetNbInputFrames( int nbInputFrames);
	inline BOOL SetNbOutputFrames( int nbOutputFrames);
   inline BOOL SetTrashCallbackInfo(SapXferCallback pCallback, void *pContext);

   void SetTransfer(SapTransfer *pXfer) { m_Xfer = pXfer; }
   void InternalSetFramesOnBoard(int numFrames) { m_FramesOnBoard = numFrames; }

protected:
	// Utility methods
   inline void Construct(SapXferNode *pSrc, int srcPort, SapXferNode *pDst, int dstPort, BOOL regCallback);

protected:
   // Source/destination node information
   SapXferNode*	m_pSrc;
   int				m_SrcPort;
   SapXferNode*	m_pDst;
   int				m_DstPort;

   // Callback information
   BOOL            m_bRegCallback;
   SapXferCallback m_pCallback;     // Overrides SapTransfer callback if specified
   void*				 m_pContext;		// Relevant only if overriding SapTransfer callback

   SapXferCallback m_pTrashCallback;     // Overrides SapTransfer callback if specified
   void*				 m_pTrashContext;		// Relevant only if overriding SapTransfer callback

   // Transfer parameters
   EventType m_EventType;				// Current transfer event type
   EventCountSource m_EventCountSource;   // Current source of event count
   CycleMode m_CycleMode;				// Current buffer cycle mode
   FlipMode  m_FlipMode;				// Current flipping mode
   CounterStampTimeBase m_CounterStampTimeBase; // Current counter-stamp time base
   FlatFieldCycleMode m_FlatFieldCycleMode;     // Current flat_field cycle mode
   DynamicLutCycleMode m_DynamicLutCycleMode;   // Current dynamic LUT cycle mode

	int		 m_FramesPerCallback;	// Current number of frames per callback
	int		 m_FramesOnBoard;			// Current number of onboard frames
   int       m_RelativeBufferIndex;
   int       m_NbInputFrames;     //number of frames to multiply by.
   int       m_NbOutputFrames;      //number of frames to Divide by.

   SapTransfer* m_Xfer;    // Reference to transfer object (to make parameter changes active)
};

//
// SapXferPairInfo class declaration
//
class SAPCLASSBASIC_CLASS SapXferPairInfo
{
public:
	SapXferPairInfo() 
		{ m_Index = 0; m_pXfer = NULL; m_context = NULL; }
	SapXferPairInfo(SapXferPair &pair, int index, SapTransfer *pXfer) 
      { m_Pair = pair; m_Pair.SetTransfer(pXfer); m_Index = index; m_pXfer = pXfer; m_context = NULL; }

public:
	SapXferPair	         m_Pair;		// Transfer pair
	int			         m_Index;		// Index in the table
	SapTransfer*         m_pXfer;		// Corresponding transfer object
	SapXferContextInfo*  m_context;
   int                  m_MaxSnapCount;   // Maximum frame count for Snap
   SapXferPair::CycleMode m_CycleModeCap; // Cycle mode capability
   BOOL                 m_DynamicLutCap;  // Availability of dynamic look-up tables
};

//
// SapXferContextInfo class declaration
//
class SAPCLASSBASIC_CLASS SapXferContextInfo
{
public:
	SapXferContextInfo()
		{ m_PairInfo= NULL; m_dstIndex= 0; }
	SapXferContextInfo( SapXferPairInfo *pPairInfo, int dstIndex)
		{ m_PairInfo= pPairInfo; m_dstIndex= dstIndex;}

public:
	SapXferPairInfo* m_PairInfo;
	int		        m_dstIndex;
};

//
// SapXferCounterStampInfo class declaration
//
class SAPCLASSBASIC_CLASS SapXferCounterStampInfo
{
public:
   SapXferCounterStampInfo()
   {
      m_IsSupported = FALSE;
      m_IsAvailable = FALSE;
      m_MaxValue = 0;
      m_EventType = 0;
      m_TimeBase = SapXferPair::CounterStampMicroSec;
   }

   BOOL IsSupported() const { return m_IsSupported; }
   BOOL IsAvailable() const { return m_IsAvailable; }
   int GetMaxValue()  const { return m_MaxValue; }
   SapXferPair::EventType GetEventType()           const { return m_EventType; }
   SapXferPair::CounterStampTimeBase GetTimeBase() const { return m_TimeBase; }

   void SetSupported(BOOL isSupported) { m_IsSupported = isSupported; }
   void SetAvailable(BOOL isAvailable) { m_IsAvailable = isAvailable; }
   void SetMaxValue(int maxValue) { m_MaxValue = maxValue; }
   void SetEventType(SapXferPair::EventType eventType) { m_EventType = eventType; }
   void SetTimeBase(SapXferPair::CounterStampTimeBase timeBase) { m_TimeBase = timeBase; }

protected:
   BOOL m_IsSupported;
   BOOL m_IsAvailable;
   int m_MaxValue;
   SapXferPair::EventType m_EventType;
   SapXferPair::CounterStampTimeBase m_TimeBase;
};

//
// SapTransfer class declaration
//

class SAPCLASSBASIC_CLASS SapTransfer : public SapManager
{
public:
   // Transfer start modes
   typedef int StartMode;
   enum _StartMode
   {
      StartAsynchronous     = CORXFER_VAL_START_MODE_ASYNCHRONOUS,
      StartSynchronous      = CORXFER_VAL_START_MODE_SYNCHRONOUS,
      StartHalfAsynchronous = CORXFER_VAL_START_MODE_HALF_ASYNCHRONOUS,
      StartSequential       = CORXFER_VAL_START_MODE_SEQUENTIAL
   };

   // Various constants
   enum MiscValues
   {
      MaxPairs = 64,
      MaxMultiNode = 16
   };

public:
	// Constructor/Destructor
	SapTransfer(SapXferCallback pCallback = NULL, void *pContext = NULL, SapLocation location = SapLocation::ServerUnknown);
	SapTransfer(SapXferCallback pCallback, SapXferCallback pTrashCallback, void *pContext, SapLocation location = SapLocation::ServerUnknown);
	SapTransfer(const SapTransfer &xfer);
	virtual ~SapTransfer();

	SapTransfer &operator= (const SapTransfer &xfer);

public:
	// Creation/destruction
	virtual BOOL Create();
	virtual BOOL Destroy();

	virtual BOOL Connect();
	virtual BOOL Disconnect();

	// Access to implementation
	BOOL AddPair(SapXferPair &pair);
	BOOL RemoveAllPairs();
	SapXferPair *GetPair(int pairIndex);
	int GetNumPairs()							  const { return m_NumPairs;}
	const SapXferPairInfo *GetPairInfo()  const { return m_Pairs;}
   const SapXferCounterStampInfo *GetCounterStampInfo(int pairIndex) const;

   virtual CORHANDLE GetHandle()         const { return m_hXfer; }
   SapLocation GetLocation()             const { return m_Location; }

   virtual SapXferCallback GetCallback() const { return m_pCallback; }
   virtual SapXferCallback GetTrashCallback() const { return m_pTrashCallback; }
   virtual void *GetContext()            const { return m_pContext; }
   virtual BOOL IsGrabbing()             const { return m_bGrab; }
   virtual BOOL IsAutoEmpty()            const { return m_bAutoEmpty; }
	virtual BOOL IsAutoConnect()			  const { return m_bAutoConnect;}
   virtual BOOL IsConnected()            const { return m_bConnected; }
	virtual StartMode GetStartMode()      const { return m_StartMode; }
   virtual BOOL IsCycleModeAvailable(int pairIndex, SapXferPair::CycleMode cycleMode);
   virtual int GetConnectTimeout()       const { return m_ConnectTimeout; }

   BOOL SetLocation(SapLocation location);

	virtual BOOL SetCallbackInfo( SapXferCallback pCallback, void *pContext= NULL);
	virtual BOOL SetTrashCallbackInfo( SapXferCallback pTrashCallback);

	virtual void SetAutoEmpty(BOOL bAutoEmpty);
	virtual void SetAutoConnect( BOOL bAutoConnect);

   virtual BOOL IsCapabilityValid(int cap);
   virtual BOOL IsParameterValid(int param);

   virtual BOOL GetCapability(int cap, void *pValue);
   virtual BOOL GetParameter(int param, void *pValue);
   virtual BOOL SetParameter(int param, int value);
   virtual BOOL SetParameter(int param, void *pValue);

	virtual BOOL Select( int pairIndex, int srcIndex = -1, int dstIndex = -1);
	virtual BOOL Select( SapXferPair* pPair, int srcIndex = -1, int dstIndex = -1);

	virtual BOOL SetStartMode(StartMode startMode);

   virtual BOOL SetConnectTimeout(int timeout);

   // Dynamic LUT management
   BOOL IsDynamicLutAvailable(int pairIndex = 0);

#if !SAPERA_DOT_NET
   //obosolete functions that are included for compatibility
   //with older applications.
   //Use the XferMultiNode functions instead
   BOOL AddRtProDesign( SapXferMultiNode *pRtProDesign) { return AddXferMultiNode( pRtProDesign); }
   BOOL RemoveRtProDesigns( SapXferMultiNode *pRtProDesign) { return RemoveXferMultiNode( pRtProDesign);}
   BOOL RemoveAllRtProDesigns() { return RemoveAllXferMultiNode();}

   BOOL AddXferMultiNode( SapXferMultiNode *pXferMultiNode);
   BOOL RemoveXferMultiNode( SapXferMultiNode *pXferMultiNode);
   BOOL RemoveAllXferMultiNode();
#endif

	// Utility methods
   virtual BOOL SetCallbackInfo(SapXferPair* pPair);
   virtual BOOL SetTrashCallbackInfo(SapXferPair* pPair);
   virtual BOOL SetEventType(SapXferPair* pPair);	
	virtual BOOL SetEventCountSource(SapXferPair* pPair);
	virtual BOOL SetCycleMode(SapXferPair* pPair);
	virtual BOOL SetFlipMode(SapXferPair* pPair);
	virtual BOOL SetCounterStampTimeBase(SapXferPair* pPair); 
	virtual BOOL SetFlatFieldCycleMode(SapXferPair* pPair);			
	virtual BOOL SetDynamicLutCycleMode(SapXferPair* pPair);			
	virtual BOOL SetFramesPerCallback(SapXferPair* pPair);		
	virtual BOOL SetFramesOnBoard(SapXferPair* pPair);		
	virtual BOOL SetRelativeBufferIndex(SapXferPair* pPair);		
	virtual BOOL SetNbInputFrames(SapXferPair* pPair);  
	virtual BOOL SetNbOutputFrames(SapXferPair* pPair);
	virtual BOOL RegisterCallback(EventType eventType, SapXferCallback callback, void *context, UINT32 xferElement);
	virtual BOOL UnregisterCallback();
	virtual BOOL UpdateParameters( void);

   // Obsolete methods
	BOOL Add(SapXferPair &pair) { return AddPair(pair); }
	void RemoveAll()            { RemoveAllPairs(); }

public:
	// Transfer Control
	virtual BOOL Snap(int count = 1);
	virtual BOOL Grab();
	virtual BOOL Freeze();
	virtual BOOL Abort();
	virtual BOOL Wait(int timeout);
	virtual BOOL Init(BOOL resetIndex = TRUE);

protected:
	// Utility methods
   void Construct(SapXferCallback pCallback, SapXferCallback pTrashCallback, void *pContext, SapLocation location, int numPairs, const SapXferPairInfo *pPairs, BOOL bAutoEmpty, BOOL bAutoConnect= TRUE);
	virtual BOOL SetStartMode();
   virtual BOOL XferIsCycleModeAvailable(SapXferPair* pPair, SapXferPair::CycleMode cycleMode);
	virtual BOOL CreatePair(int pairIndex);
	virtual BOOL DestroyPair(int pairIndex);

   virtual BOOL GetCapabilities(int pairIndex);
   virtual BOOL SetParameters(int pairIndex);

   virtual BOOL SetParameters(void);
   void GetIndexesFromSourceDest(SapXferPair* pPair, int* srcIndex, int* dstIndex);
   void SetSourceDestIndexes(SapXferPair* pPair, int srcIndex, int dstIndex);
   virtual BOOL FindPairIndex(SapXferPair* pPair, int* pIndex);

	// Callback functions
	static SAPSTATUS CCONV OnNormal(void *context, UINT32 eventType, UINT32 eventCount);
	static SAPSTATUS CCONV OnTrash(void *context, UINT32 eventType, UINT32 eventCount);
	static SAPSTATUS CCONV OnNormalEx(void *context, COREVENTINFO eventInfo);
	BOOL ExecuteCallback(void *context, UINT32 eventType, UINT32 eventCount, COREVENTINFO eventInfo);

protected:
	// Parameters
	SapXferCallback	m_pCallback;						// Application callback function
	SapXferCallback	m_pTrashCallback;				   // Application callback function for trash buffers
	void					*m_pContext;						// Application context
	SapLocation			m_Location;							// Transfer location
	SapXferPairInfo	m_Pairs[MaxPairs];	         // Table of transfer pairs
	int					m_NumPairs;							// Number of transfer pairs
	BOOL	            m_bAutoEmpty;	               // TRUE to automatically empty buffers
	BOOL					m_bAutoConnect;					// TRUE to automatically connect the transfer object to the hardware
																	// when calling the create function
	BOOL              m_bMultiBuffersUsed[MaxPairs];// True if pair supports multibuffer mechanism
	int               m_pXferElement;
	// Counter stamp capabilities
	SapXferCounterStampInfo m_CounterStampInfo[MaxPairs];

	BOOL            m_bNewCallbackViaConstructor;
	BOOL            m_bOldCallback;

#if !SAPERA_DOT_NET
   SapXferMultiNode  *m_pXferMultiNode[ MaxMultiNode];
#endif

   // Sapera transfer module settings
   CORXFER   m_hXfer;         // Transfer handle
   StartMode m_StartMode;     // Current start mode
   int m_ConnectTimeout;      // Override the communication timeout when calling Connect()

	// Flags
   BOOL m_bGrab;           // TRUE if transfer is active
   BOOL m_NoConnect;       // TRUE for some special transfer pairs that do not need to be connected
	BOOL m_bConnected;		// TRUE if transfer object is connected to hardware, FALSE otherwise
}; 

//
// SapXferCallbackInfo class declaration
//
class SAPCLASSBASIC_CLASS SapXferCallbackInfo
{
public:
   SapXferCallbackInfo(SapTransfer *pXfer, void *context, SapXferPair::EventType eventType, int eventCount, BOOL isTrash, int pairIndex)
      { m_pXfer = pXfer; m_Context = context; m_EventType = eventType; m_EventCount = eventCount; m_bTrash = isTrash; m_PairIndex = pairIndex; m_NewCallback = FALSE;}
   SapXferCallbackInfo(SapTransfer *pXfer, void *context,  COREVENTINFO eventInfo, BOOL isTrash, int pairIndex);
	~SapXferCallbackInfo() {}


   // Obsolete constructor
   SapXferCallbackInfo(void *context, SapXferPair::EventType eventType, int eventCount, BOOL isTrash, int pairIndex)
      { m_pXfer = NULL; m_Context = context; m_EventType = eventType; m_EventCount = eventCount; m_bTrash = isTrash; m_PairIndex = pairIndex; }

   SapTransfer *GetTransfer()                const { return m_pXfer; }
	void *GetContext()                        const { return m_Context; }
	BOOL IsTrash()                            const { return m_bTrash; }
	int GetPairIndex()                        const { return m_PairIndex; }
   COREVENTINFO GetEventInfo()               const { return m_EventInfo; }

   //Event Count
   int GetEventCount()                       const { return m_EventCount; }
   BOOL GetEventCount(int *eventCount);

   //Event Type
   SapXferPair::EventType GetEventType()     const { return m_EventType; }
   BOOL GetEventType(SapXferPair::EventType *eventType);

    //Timestamp
   BOOL GetHostTimeStamp(UINT64 *hostTimeStamp);
   BOOL GetAuxiliaryTimeStamp(UINT64 *auxTimeStamp);
 

	// Custom Parameters
	BOOL GetCustomData(void **customData);
	BOOL GetCustomSize(int *customSize);

	// Unnamed Parameters
	BOOL GetGenericParam0(int *paramValue);
	BOOL GetGenericParam1(int *paramValue);
	BOOL GetGenericParam2(int *paramValue);
	BOOL GetGenericParam3(int *paramValue);

protected:
   SapTransfer *m_pXfer;
	void *m_Context;
	SapXferPair::EventType m_EventType;
	int m_EventCount;
	BOOL m_bTrash;
	int m_PairIndex;
	COREVENTINFO m_EventInfo;
   BOOL m_NewCallback;
};

//
// SapXferPair class inline implementation
//
inline BOOL SapXferPair::SetCallbackInfo(SapXferCallback pCallback, void *pContext)
{ 	
   m_pCallback = pCallback; 
   m_pContext = pContext; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetCallbackInfo(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetTrashCallbackInfo(SapXferCallback pCallback, void *pContext)
{ 	
   m_pTrashCallback = pCallback; 
   m_pTrashContext = pContext; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetTrashCallbackInfo(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetEventType(EventType eventType)		
{ 	
   m_EventType = eventType; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetEventType(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetEventCountSource(EventCountSource eventCountSource) 
{ 	
   m_EventCountSource = eventCountSource; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetEventCountSource(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetCycleMode(CycleMode cycleMode)		
{ 
   m_CycleMode = cycleMode; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetCycleMode(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetFlipMode(FlipMode flipMode)			
{ 
   m_FlipMode = flipMode; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetFlipMode(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetCounterStampTimeBase(CounterStampTimeBase counterStampTimeBase) 
{ 
   m_CounterStampTimeBase = counterStampTimeBase; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetCounterStampTimeBase(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetFlatFieldCycleMode(FlatFieldCycleMode flatFieldCycleMode)			
{ 
   m_FlatFieldCycleMode = flatFieldCycleMode; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetFlatFieldCycleMode(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetDynamicLutCycleMode(DynamicLutCycleMode dynamicLutCycleMode)			
{ 
   m_DynamicLutCycleMode = dynamicLutCycleMode; 
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetDynamicLutCycleMode(this);
   else
      return TRUE; 
}

inline BOOL SapXferPair::SetFramesPerCallback(int numFrames)  
{ 
	int nDstCount= GetDst()->GetCount();

	if( numFrames > nDstCount/2)
		numFrames= nDstCount/2 + ((nDstCount&1)? 1: 0);

	if (numFrames > 0)
   {
		m_FramesPerCallback = numFrames; 

      if (m_Xfer && *m_Xfer)
         m_Xfer->SetFramesPerCallback(this);
      else
         return TRUE; 
   }
	
	return FALSE; 
}

inline BOOL SapXferPair::SetFramesOnBoard( int numFrames)		
{ 
   if (numFrames > 0)
   {
		m_FramesOnBoard= numFrames; 

      if (m_Xfer && *m_Xfer)
      {
         if (!m_Xfer->SetFramesOnBoard(this))
            return FALSE;
         return m_Xfer->UpdateParameters();
      }
      else
         return TRUE; 
   }

	return FALSE; 
}

inline BOOL SapXferPair::SetRelativeBufferIndex( int relativeBufferIndex)		
{ 
   m_RelativeBufferIndex = relativeBufferIndex;
   if (m_Xfer && *m_Xfer)
      return m_Xfer->SetRelativeBufferIndex(this);
   else
      return TRUE; 
}
   
inline BOOL SapXferPair::SetNbInputFrames( int nbInputFrames)  
{
   if (nbInputFrames > 0)
   {
      m_NbInputFrames = nbInputFrames;    

      if (m_Xfer && *m_Xfer)
         return m_Xfer->SetNbInputFrames(this);
      else
         return TRUE; 
   }

   return FALSE;
}

inline BOOL SapXferPair::SetNbOutputFrames( int nbOutputFrames)  
{
   if (nbOutputFrames > 0)
   {
      m_NbOutputFrames = nbOutputFrames;

      if (m_Xfer && *m_Xfer)
         return m_Xfer->SetNbOutputFrames(this);
      else
         return TRUE; 
   }

   return FALSE;
}

inline void SapXferPair::Construct(SapXferNode *pSrc, int srcPort, SapXferNode *pDst, int dstPort, BOOL regCallback)
{
   m_pSrc    = pSrc;
   m_SrcPort = srcPort;
   m_pDst    = pDst;
   m_DstPort = dstPort;

   m_bRegCallback			= regCallback;
   m_pCallback				= NULL;
   m_pContext				= NULL;

   m_pTrashCallback				= NULL;
   m_pTrashContext				= NULL;

	m_FramesPerCallback	= 1;
	m_FramesOnBoard		= InvalidFramesOnBoard;

	m_RelativeBufferIndex   = 0;  

   m_NbInputFrames = 1;
   m_NbOutputFrames = 1;

   m_EventType = EventEndOfFrame;
   m_EventCountSource = EventCountDst;
   m_CycleMode = CycleUnknown;
   m_FlipMode  = FlipNone;
   m_CounterStampTimeBase = CounterStampMicroSec;
   m_FlatFieldCycleMode = FlatFieldCycleOff;
   m_DynamicLutCycleMode = DynamicLutCycleOff;

   m_Xfer = NULL;
}

#endif   // _SAPTRANSFER_H_