#include "StdAfx.h"
#include "CHCameraControls/CameraControl.h"
#include "CHCameraControls/CameraBuffer.h"
#include <omp.h>

CCameraControl::CCameraControl(int nIndex) : m_nIndex(nIndex)
{	
	m_pCC2P				= NULL;

	m_nTotalIndex		= -1;
	m_nScanIndex		= 0;
	m_nGrabCount		= 0;
	m_nFrameCount		= 0;
	m_nFlipMode			= FlipNone;
	m_strCameraName		= _T("");

	m_nWidth			= 0;
	m_nWidthStep		= 0;
	m_nHeight			= 0;
	m_nChannels			= 0;
	m_nDepth			= 0;
	m_nLostFrame		= 0;
	m_nLostPacket		= 0;
	m_nSwCount			= 0;
	m_nHwCount			= 0;

	m_nFrameIndex		= -1;

	m_bGrabbing			= FALSE;
	m_bConnected		= FALSE;
	m_nTriggerMode		= ModeFreeRun;
	m_nTriggerSource	= SourceAutomatic;
	
	m_pCameraFrameBuffer		= NULL;

	InitializeCriticalSection(&m_csFrameBuffer);
}

CCameraControl::~CCameraControl(void)
{
	m_pCC2P				= NULL;

	m_nWidth			= 0;
	m_nWidthStep		= 0;
	m_nHeight			= 0;
	m_nChannels			= 0;
	m_nDepth			= 0;
	m_nFrameIndex		= -1;
	m_nLostFrame		= 0;
	m_nLostPacket		= 0;
	m_nSwCount			= 0;
	m_nHwCount			= 0;

	m_bGrabbing			= FALSE;
	m_bConnected		= FALSE;
	m_nTriggerMode		= ModeFreeRun;

	DeleteFrameBuffer();

	DeleteCriticalSection(&m_csFrameBuffer);
}

void CCameraControl::AllocateFrameBuffer(int nWidth, int nHeight, int nChannels, int nFrameCount, const CString& strBufferName)
{
	m_nWidth = nWidth;
	m_nHeight = nHeight;
	m_nChannels = nChannels;

	if (m_pCameraFrameBuffer!=NULL) delete m_pCameraFrameBuffer;
	m_pCameraFrameBuffer = new CCameraBuffer();
	if (m_pCameraFrameBuffer)
	{
		m_pCameraFrameBuffer->CreateBuffer(m_nWidth, m_nHeight, m_nChannels, m_nFrameCount, strBufferName);
		m_curFrameImage.CreateImage(m_nWidth, m_nHeight, 8, m_nChannels);
	}
}

void CCameraControl::DeleteFrameBuffer()
{
	if (m_pCameraFrameBuffer!=NULL) 
		delete m_pCameraFrameBuffer;
	m_pCameraFrameBuffer = NULL;
}

BOOL CCameraControl::ClearSharedMemory(int nScanIndex)
{
	if (m_pCameraFrameBuffer==NULL) return FALSE;

	int nIndex = nScanIndex % MAX_BUFFER_SCAN_COUNT;

	return m_pCameraFrameBuffer->ClearBuffer(nIndex);
}

// load save 
BOOL CCameraControl::SaveImage(const CString& strFilename)
{
	if (m_pCameraFrameBuffer==NULL) return FALSE;

	EnterCriticalSection(&m_csFrameBuffer);
	if (m_nFrameIndex<0 || m_nFrameIndex>(m_nFrameCount-1)) 
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// get shared frame buffer ptr
	int nFrameIndex = m_nFrameIndex;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nFrameIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	LeaveCriticalSection(&m_csFrameBuffer);

	return m_curFrameImage.SaveImage(strFilename);
}

BOOL CCameraControl::SaveImage(int nIndex, const CString& strFilename)
{
	if (m_pCameraFrameBuffer==NULL) return FALSE;

	if (nIndex<0 || nIndex>(m_nFrameCount-1)) return FALSE;

	// get shared image ptr
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		return FALSE;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	return m_curFrameImage.SaveImage(strFilename);
}

// frame image
BOOL CCameraControl::GetImage(int nLeft, int nTop, int nWidth, int nHeight, BYTE* pImage)
{
	if (m_pCameraFrameBuffer==NULL) return FALSE;

	EnterCriticalSection(&m_csFrameBuffer);
	if (m_nFrameIndex<0 || m_nFrameIndex>(m_nFrameCount-1)) 
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// get shared image ptr
	int nFrameIndex = m_nFrameIndex;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nFrameIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	LeaveCriticalSection(&m_csFrameBuffer);

	return m_curFrameImage.GetSubImage(nLeft, nTop, nWidth, nHeight, m_nChannels, pImage);
}

BOOL CCameraControl::GetImage(int nIndex, int nLeft, int nTop, int nWidth, int nHeight, BYTE* pImage)
{
	if (m_pCameraFrameBuffer==NULL) return FALSE;

	if (nIndex<0 || nIndex>(m_nFrameCount-1)) return FALSE;

	// get shared image ptr
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		return FALSE;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	return m_curFrameImage.GetSubImage(nLeft, nTop, nWidth, nHeight, m_nChannels, pImage);
}

void* CCameraControl::GetImageAddress()
{
	if (m_pCameraFrameBuffer==NULL) return NULL;

	EnterCriticalSection(&m_csFrameBuffer);
	if (m_nFrameIndex<0 || m_nFrameIndex>(m_nFrameCount-1)) 
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return NULL;
	}

	// get shared image ptr
	int nFrameIndex = m_nFrameIndex;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nFrameIndex);

	LeaveCriticalSection(&m_csFrameBuffer);

	return pImageData;
}

void* CCameraControl::GetImageAddress(int nIndex)
{
	if (m_pCameraFrameBuffer==NULL) return NULL;

	if (nIndex<0 || nIndex>(m_nFrameCount-1)) return NULL;

	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nIndex);

	return pImageData;
}

BOOL CCameraControl::GetImageData(CCHImageData *pImageData)
{
	if (m_pCameraFrameBuffer==NULL || pImageData==NULL) return NULL;

	EnterCriticalSection(&m_csFrameBuffer);
	if (m_nFrameIndex<0 || m_nFrameIndex>(m_nFrameCount-1)) 
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// get shared image ptr
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageBuff = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);
	if (pImageInfo==NULL || pImageBuff==NULL)
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// check image size
	if (pImageData->GetWidth()!=m_nWidth || pImageData->GetHeight()!=m_nHeight || pImageData->GetChannels()!=m_nChannels)
	{
		if (pImageData->CreateImage(m_nWidth, m_nHeight, 8, m_nChannels)==FALSE)
		{
			LeaveCriticalSection(&m_csFrameBuffer);
			return FALSE;
		}
	}

	// copy shared image to frame image
	memcpy(pImageData->GetImageBuffer(), pImageBuff, pImageData->GetImageSize());

	LeaveCriticalSection(&m_csFrameBuffer);

	return TRUE;
}

BOOL CCameraControl::GetImageData(int nIndex, CCHImageData *pImageData)
{
	if (m_pCameraFrameBuffer==NULL || pImageData==NULL) return FALSE;

	if (nIndex<0 || nIndex>(m_nFrameCount-1)) return FALSE;

	// get shared image ptr
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageBuff = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nIndex);
	if (pImageInfo==NULL || pImageBuff==NULL)
	{
		return FALSE;
	}
	
	// check image size
	if (pImageData->GetWidth()!=m_nWidth || pImageData->GetHeight()!=m_nHeight || pImageData->GetChannels()!=m_nChannels)
	{
		if (pImageData->CreateImage(m_nWidth, m_nHeight, 8, m_nChannels)==FALSE)
		{
			return FALSE;
		}
	}

	// copy shared image to frame image
	memcpy(pImageData->GetImageBuffer(), pImageBuff, pImageData->GetImageSize());

	return TRUE;
}

CCHImageData* CCameraControl::GetImagePtr()
{
	if (m_pCameraFrameBuffer==NULL) return NULL;

	EnterCriticalSection(&m_csFrameBuffer);
	if (m_nFrameIndex<0 || m_nFrameIndex>(m_nFrameCount-1)) 
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// get shared image ptr
	int nFrameIndex = m_nFrameIndex;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nFrameIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		LeaveCriticalSection(&m_csFrameBuffer);
		return FALSE;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	LeaveCriticalSection(&m_csFrameBuffer);

	return &m_curFrameImage;
}

CCHImageData* CCameraControl::GetImagePtr(int nIndex)
{
	if (m_pCameraFrameBuffer==NULL) return NULL;

	if (nIndex<0 || nIndex>(m_nFrameCount-1)) return NULL;

	// get shared image ptr
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
	const CCameraBufferInfo* pImageInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	const BYTE* pImageData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, nIndex);
	if (pImageInfo==NULL || pImageData==NULL)
	{
		return NULL;
	}

	// copy shared image to frame image
	memcpy(m_curFrameImage.GetImageBuffer(), pImageData, m_curFrameImage.GetImageSize());

	return &m_curFrameImage;
}


BOOL CCameraControl::ImageFlip(int nFlipMode, BYTE *pSrcBuf, BYTE* pDstBuf, int nWidth, int nHeiht, int nChannels)
{
	int nWidthStep = nWidth * nChannels;

	switch(nFlipMode)
	{
	case FlipVertical:
		{
			BYTE *pBuffDataSrc = pSrcBuf;								// set fist line start ptr
			BYTE *pBuffDataDst = pDstBuf + nWidthStep*(nHeiht-1);		// set end line start ptr		
			for (int i=0; i<nHeiht; i++)
			{
				memcpy(pBuffDataDst, pSrcBuf, sizeof(BYTE)*nWidthStep);
				pSrcBuf += nWidthStep;
				pBuffDataDst -= nWidthStep;
			}
		}
		break;
	case FlipHorizontal:
		{
			BYTE *pBuffDataSrc = NULL;			
			BYTE *pBuffDataDst = NULL;			
			for (int i=0; i<nHeiht; i++)
			{
				pBuffDataSrc = pSrcBuf + ((i+1)*nWidthStep) - nChannels;	// set line end ptr
				pBuffDataDst = pDstBuf + (i*nWidthStep);					// set line start ptr
				for (int j=0; j<nWidth; j++)
				{
					memcpy(pBuffDataDst, pBuffDataSrc, sizeof(BYTE)*nChannels);
					pBuffDataSrc -= nChannels;
					pBuffDataDst += nChannels;
				}
			}
		}
		break;
	case FlipBoth:
		{
			BYTE *pBuffDataSrc = NULL;			
			BYTE *pBuffDataDst = NULL;	
			for (int i=0; i<nHeiht; i++)
			{
				pBuffDataSrc = pSrcBuf + ((i+1)*nWidthStep) - nChannels;	// set fist line start ptr
				pBuffDataDst = pDstBuf + ((nHeiht-1)*nWidthStep);			// set end line start ptr	
				for (int j=0; j<nWidth; j++)
				{
					memcpy(pBuffDataDst, pBuffDataSrc, sizeof(BYTE)*nChannels);
					pBuffDataSrc -= nChannels;
					pBuffDataDst += nChannels;
				}
			}
		}
		break;

	default:
		return FALSE;
		break;
	}

	return TRUE;

}

BOOL CCameraControl::SetTriggerProcess()
{
	return TRUE;
}

BOOL CCameraControl::SetTriggerProcess( int nPosUmX, int nPosUmY )
{
	return TRUE;
}

BOOL CCameraControl::SetExposureTime( double dValue )
{
	return TRUE;
}

BOOL CCameraControl::GetExposureTime( double& dValue )
{
	return TRUE;
}

BOOL CCameraControl::SetExposureAuto( BOOL bAuto )
{
	return TRUE;
}

#include "CameraControl_FlyCapture.h"
CCameraControl* CameraControlNew(int nCamIndex)
{
	CCameraControl* pCameraControlBase = (CCameraControl*)new CCameraControl_FlyCapture(nCamIndex);
	return pCameraControlBase;
}