#pragma once

class CCHImageData;

class CSharedMemory
{
public:
	CSharedMemory(void)				
	{ 
		m_pSemaPhore		= NULL; 
		m_pAsignedMemory	= NULL;
		m_pSharedMemory		= NULL;

		Reset(); 
	}

	virtual ~CSharedMemory(void)		
	{ 
		Reset(); 
	}

	int GetMemoryCount()	
	{ 
		return m_nMemoryCount; 
	}

	BOOL LockMemory(int nMemoryIndex)
	{
		if (nMemoryIndex<0 || nMemoryIndex>=m_nMemoryCount) return FALSE;

		if (m_pSemaPhore[nMemoryIndex]) 
		{
			m_pSemaPhore[nMemoryIndex]->Lock();
		}
		else
		{
			return FALSE;
		}
		return TRUE;
	}

	BOOL UnlockMemory(int nMemoryIndex)
	{
		if (nMemoryIndex<0 || nMemoryIndex>=m_nMemoryCount) return FALSE;

		if (m_pSemaPhore[nMemoryIndex]) 
		{
			m_pSemaPhore[nMemoryIndex]->Unlock();
		}
		else
		{
			return FALSE;
		}
		return TRUE;
	}

protected:

	void Reset()
	{
		if(m_pSharedMemory)
		{
			for (int i=0; i<m_nMemoryCount; i++)
			{
				UnmapViewOfFile(m_pSharedMemory[i]); 		
			}
			delete [] m_pSharedMemory;
			m_pSharedMemory = NULL;		
		}

		if(m_pAsignedMemory)
		{
			for (int i=0; i<m_nMemoryCount; i++)
			{
				CloseHandle(m_pAsignedMemory[i]);
			}
			delete [] m_pAsignedMemory;
			m_pAsignedMemory = NULL;
		}

		if (m_pSemaPhore)
		{
			for (int i=0; i<m_nMemoryCount; i++)
			{
				delete m_pSemaPhore[i];
			}
			delete [] m_pSemaPhore;
			m_pSemaPhore = NULL;
		}

		m_nMemoryCount = 0;
	}

	void SetMemoryCount(int nCount)
	{
		if (nCount<1) return;

		m_nMemoryCount = nCount;
	}

	int					m_nMemoryCount;
	CSemaphore**		m_pSemaPhore;
	HANDLE*				m_pAsignedMemory;
	BYTE**				m_pSharedMemory;
};

class CCameraBufferInfo
{
public:
	CCameraBufferInfo(void)				{ Reset(); }
	virtual ~CCameraBufferInfo(void)	{ Reset(); }
	void Reset()
	{
		sCameraIndex	= -1;
		sScanIndex		= -1;
		nImageCount		= 0;
	}
	short	sCameraIndex;
	short	sScanIndex;
	int		nImageCount;
};

class AFX_EXT_CLASS CCameraBuffer : public CSharedMemory
{
public:
	CCameraBuffer();
	virtual ~CCameraBuffer(void);
	
	int		GetBufferCount() const;
	int		GetScanCount() const;							
	int		GetBufferWidth() const;
	int		GetBufferHeight() const;
	int		GetBufferChannels() const;
	
	BOOL	CreateBuffer(int nWidth, int nIHeight, int nChannels, int nCount, const CString& strBufferName, int nScanCount=1);
	void	DeleteBuffer();
	BOOL	ClearBuffer(int nScanIndex);

	const CCameraBufferInfo* GetBufferInfo(int nScanIndex) const;
	const BYTE* GetBufferData(int nScanIndex) const;
	const BYTE* GetBufferData(int nScanIndex, int nBufferIndex) const;

	CCameraBufferInfo* GetBufferInfo(int nScanIndex);
	BYTE* GetBufferData(int nScanIndex);
	BYTE* GetBufferData(int nScanIndex, int nBufferIndex);

	CCameraBufferInfo* GetBufferData(int nScanIndex, BYTE** pBufferData);
	CCameraBufferInfo* GetBufferData(int nScanIndex, int nBufferIndex, BYTE** pBufferData);

	BOOL SetBufferInfo(int nScanIndex, CCameraBufferInfo *pBufferInfo);
	BOOL SetBufferData(int nScanIndex, int nBufferIndex, BYTE* pImageData, int nBufferSize);
	BOOL SetBufferData(int nScanIndex, int nBufferIndex, CCameraBufferInfo *pBufferInfo, BYTE* pBufferData, int nBufferSize);

protected:
//	int					m_nCameraIndex;
	int					m_nScanCount;

	int					m_nBufferWidth;
	int					m_nBufferHeight;
	int					m_nBufferChannels;
	int					m_nBufferCount;

	CCameraBufferInfo**	m_pBufferInfo;
	BYTE**				m_pBufferData;
	CCHImageData**		m_pBufferImage;

	DWORD				m_nBufferInfoSize;
	DWORD				m_nBufferDataSize;
};