#include "StdAfx.h"
#include "CameraControl_Sapera.h"
#include "SapClassBasic.h"
#include "SapAcquisition.h"
#include "CHCameraControls/CameraBuffer.h"

CCameraControl_Sapera::CCameraControl_Sapera(int nIndex) : CCameraControl(nIndex)
{
	m_pAcq			= NULL;
	m_pBuffers		= NULL;
	m_pXfer			= NULL;
	m_nSnapFrameCount = 0;

}

CCameraControl_Sapera::~CCameraControl_Sapera()
{
	Disconnect();

	DeleteObjects();
}

BOOL CCameraControl_Sapera::GetGrabbing()
{
	if (m_pXfer && *m_pXfer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		return m_bGrabbing;
	}

	return FALSE;
}

int CCameraControl_Sapera::GetFrameIndex()
{
	if (m_pBuffers && *m_pBuffers) 
	{
		m_nFrameIndex = m_pBuffers->GetIndex();

		return m_nFrameIndex;
	}

	return -1;
}

int	CCameraControl_Sapera::Connect(const CCameraControlInfo& controlInfo)
{
	if (m_bConnected) return 0;

	m_nTotalIndex	= controlInfo.GetIndex();
	m_nGrabCount	= controlInfo.GetGrabCount();
	m_nFrameCount	= controlInfo.GetFrameCount();

// 	m_nGantryIndex	= controlInfo.nGantryIndex;
// 	m_nHeaderIndex	= controlInfo.nHeaderIndex;

	SapLocation loc(controlInfo.GetGrabberIndex(), controlInfo.GetChannelIndex());

	CString strTemp = controlInfo.GetConnectionPort();

	if (!AllocateObjects(loc, strTemp, m_nGrabCount))
	{
		m_bConnected = FALSE;
		return -1;
	}

	if (!CreateObjects())
	{
		m_bConnected = FALSE;
		return -2;
	}

	// Get image info
	m_nWidth		= m_pBuffers->GetWidth();
	m_nWidthStep	= m_pBuffers->GetPitch();
	m_nHeight		= m_pBuffers->GetHeight();
	m_nDepth		= m_pBuffers->GetPixelDepth();
	m_nChannels		= m_pBuffers->GetBytesPerPixel();

	// alloc frame buffer
	CString temp = _T("");
	temp.Format(_T("Sapera_%02d"), m_nTotalIndex);
	AllocateFrameBuffer(m_nWidth, m_nHeight, m_nChannels, m_nFrameCount, temp);
		
	SetTriggerMode(ModeInternal);

	m_bConnected = TRUE;

	return 1;
}

int	CCameraControl_Sapera::Grab()
{
	if (m_pXfer && *m_pXfer && m_pCameraFrameBuffer) 
	{
 		m_bGrabbing = m_pXfer->IsGrabbing();
 
 		if (m_bGrabbing) return -1;
		
		m_nFrameIndex = -1;
		m_nSnapFrameCount = m_nFrameCount;

		// set shared image info
		int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
		CCameraBufferInfo *pInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
		if (pInfo)
		{
			pInfo->sCameraIndex = m_nIndex; // mch 20160823
			pInfo->sScanIndex = m_nScanIndex;
			pInfo->nImageCount = 0;
		}

		m_pXfer->Init(TRUE);
		m_pBuffers->Clear();
		m_pBuffers->ResetIndex();

		if (!m_pXfer->Grab())
		{
			return -2;
		}

		m_bGrabbing = TRUE;

		return 1;
	}

	return 0;
}

int	CCameraControl_Sapera::Snap()
{
	if (m_pXfer && *m_pXfer && m_pCameraFrameBuffer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		if (m_bGrabbing) return -1;

		m_nFrameIndex = -1;
		m_nSnapFrameCount = m_nFrameCount;

		// set shared image info
		int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
		CCameraBufferInfo *pInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
		if (pInfo)
		{
			pInfo->sCameraIndex = m_nIndex; // mch 20160823
			pInfo->sScanIndex = m_nScanIndex;
			pInfo->nImageCount = 0;
		}

		m_pXfer->Init(TRUE);
		m_pBuffers->Clear();
		m_pBuffers->ResetIndex();

		if (!m_pXfer->Snap())
		{
			return -2;
		}

		m_bGrabbing = TRUE;

		return 1;
	}

	return 0;
}

int	CCameraControl_Sapera::Snap(int nCount)
{
	if (m_pXfer && *m_pXfer && m_pCameraFrameBuffer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		if (m_bGrabbing) return -1;

		m_nFrameIndex = -1;
		m_nSnapFrameCount = nCount;

		// set shared image info
		int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
		CCameraBufferInfo *pInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
		if (pInfo)
		{
			pInfo->sCameraIndex = m_nIndex; // mch 20160823
			pInfo->sScanIndex = m_nScanIndex;
			pInfo->nImageCount = 0;
		}

		m_pXfer->Init(TRUE);
		m_pBuffers->Clear();
		m_pBuffers->ResetIndex();

		if (!m_pXfer->Snap(nCount))
		{
			return -2;
		}

		m_bGrabbing = TRUE;

		return 1;
	}

	return 0;
}

int	CCameraControl_Sapera::Snap(int nCount, UINT nWaitTime)
{
	if (m_pXfer && *m_pXfer && m_pCameraFrameBuffer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		if (m_bGrabbing) return -1;

		m_nFrameIndex = -1;
		m_nSnapFrameCount = nCount;

		// set shared image info
		int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;
		CCameraBufferInfo *pInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
		if (pInfo)
		{
			pInfo->sCameraIndex = m_nIndex; // mch 20160823
			pInfo->sScanIndex = m_nScanIndex;
			pInfo->nImageCount = 0;
		}

		m_pXfer->Init(TRUE);
		m_pBuffers->Clear();
		m_pBuffers->ResetIndex();

		if (!m_pXfer->Snap(nCount))
		{
			return -2;
		}

		m_pXfer->Wait(nWaitTime);

		m_pXfer->Abort();

		m_bGrabbing = m_pXfer->IsGrabbing();

		return 1;
	}

	return 0;
}

int CCameraControl_Sapera::Freeze()
{
	int nReturn = 0;

	if (m_pXfer && *m_pXfer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		if (!m_bGrabbing) return 1;

		nReturn = m_pXfer->Freeze();

		m_bGrabbing = m_pXfer->IsGrabbing();
	}

	return nReturn;
}

int CCameraControl_Sapera::Abort()
{
	if (m_pXfer && *m_pXfer) 
	{
		m_bGrabbing = m_pXfer->IsGrabbing();

		if (!m_bGrabbing) return -1;

		m_pXfer->Abort();
		
		m_bGrabbing = m_pXfer->IsGrabbing();
	}

	return 1;
}

int CCameraControl_Sapera::Disconnect()
{
	Abort();

	DestoryObjects();

	DeleteObjects();

	return 1;
}

BOOL CCameraControl_Sapera::AllocateObjects(const SapLocation& loc, CString strCamfile, int nSnapCount)
{
	char *str_value = NULL;

#ifdef _UNICODE
	int length = WideCharToMultiByte(CP_ACP, 0, strCamfile.GetBuffer(), -1, NULL, 0, NULL,NULL); 
	str_value = new char[length]; 
	WideCharToMultiByte(CP_ACP, 0, strCamfile.GetBuffer(), -1, str_value, length, NULL, NULL); 
#else
	int length = strCamfile.GetLength();
	str_value = new char[length+1]; 
	memcpy(str_value, strCamfile.GetBuffer(), sizeof(char)*length);
	str_value[length] = NULL;
#endif

	if (str_value==NULL) 
	{
		return FALSE;
	}

	m_pAcq			= new SapAcquisition(loc, str_value);
	m_pBuffers		= new SapBuffer(nSnapCount, m_pAcq);
	m_pXfer			= new SapAcqToBuf(m_pAcq, m_pBuffers, XferCallbackFunc, this);
	
	delete [] str_value;

	return TRUE;
}

BOOL CCameraControl_Sapera::CreateObjects()
{
	// Create acquisition object
	if (m_pAcq && !*m_pAcq && !m_pAcq->Create())
	{
		return FALSE;
	}

	// Create buffer object
	if (m_pBuffers && !*m_pBuffers && !m_pBuffers->Create())
	{
		return FALSE;
	}

	// Create transfer object
	if (m_pXfer && !*m_pXfer && !m_pXfer->Create())
	{
		return FALSE;
	}

	return TRUE;
}

void CCameraControl_Sapera::DestoryObjects()
{
	// Stop acquisition
	if (m_bGrabbing) Abort();

	// Destroy transfer object
	if (m_pXfer && *m_pXfer) 
	{
		m_pXfer->Destroy();
	}

	// Destroy buffer object
	if (m_pBuffers && *m_pBuffers) 
	{
		m_pBuffers->Destroy();
	}

	// Destroy acquisition object
	if (m_pAcq && *m_pAcq) 
	{
		m_pAcq->Destroy();
	}
}

void CCameraControl_Sapera::DeleteObjects()
{
	if (m_pXfer)		
	{
		delete m_pXfer; 
		m_pXfer = NULL;
	}

	if (m_pBuffers)		
	{
		delete m_pBuffers; 
		m_pBuffers = NULL;
	}

	if (m_pAcq)			
	{
		delete m_pAcq; 
		m_pAcq = NULL;
	}

}

void CCameraControl_Sapera::XferCallbackFunc(SapXferCallbackInfo *pInfo)
{
	if (pInfo->IsTrash())
	{
		return;
	}
	
	CCameraControl_Sapera *pThis= (CCameraControl_Sapera *) pInfo->GetContext();
	pThis->XferCallback(pInfo);
}


void CCameraControl_Sapera::XferCallback(SapXferCallbackInfo *pInfo)
{
	if (!m_pBuffers || !m_pCameraFrameBuffer) return;

	// set frame index
	m_nFrameIndex = (++m_nFrameIndex) % m_nFrameCount;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;

	// get buffer ptr
	CCameraBufferInfo *pFrameBuffInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	BYTE *pFrameBuffData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);

	BYTE *pBuffData = NULL;
	if (pFrameBuffData && pFrameBuffInfo && m_pBuffers->GetAddress((void**)&pBuffData))
	{
		if (m_nFlipMode!=FlipNone)
		{
			if (ImageFlip(m_nFlipMode, pBuffData, pFrameBuffData, m_nWidth, m_nHeight, m_nChannels)==FALSE)
			{
				memcpy(pFrameBuffData, pBuffData, m_curFrameImage.GetImageSize()); // ½ÇÆнÃ, ±×³É º¹»ç
			}
		}
		else
		{
			memcpy(pFrameBuffData, pBuffData, m_curFrameImage.GetImageSize());
		}

		// set image info
		pFrameBuffInfo->sCameraIndex = m_nIndex; // mch 20160823
		pFrameBuffInfo->sScanIndex = m_nScanIndex;
		pFrameBuffInfo->nImageCount = m_nFrameIndex + 1;

		m_pCameraFrameBuffer->UnlockMemory(nScanIndex);
		m_pBuffers->ReleaseAddress((void*)pBuffData);
	}

	if (m_pCC2P)
	{	
		m_pCC2P->ICC2P_FrameCaptured(m_nIndex, m_nFrameIndex, m_nFrameCount);

		if ((m_nSnapFrameCount - 1) == m_nFrameIndex)
		{
			m_pCC2P->ICC2P_SnapCompleted(m_nIndex, m_nSnapFrameCount);
		}
	}
}


void CCameraControl_Sapera::SetTriggerMode(int nMode, int nCount)
{
	m_nTriggerMode = nMode;

	if (m_pAcq && *m_pAcq) 
	{
		switch(m_nTriggerMode)
		{
		case ModeFreeRun:
			m_pAcq->SetParameter(CORACQ_PRM_INT_FRAME_TRIGGER_ENABLE, 0);
			m_pAcq->SetParameter(CORACQ_PRM_EXT_TRIGGER_ENABLE, CORACQ_VAL_EXT_TRIGGER_OFF);
			break;

		case ModeInternal:
			m_pAcq->SetParameter(CORACQ_PRM_EXT_TRIGGER_ENABLE, CORACQ_VAL_EXT_TRIGGER_OFF);
			m_pAcq->SetParameter(CORACQ_PRM_INT_FRAME_TRIGGER_ENABLE, 1);
			break;

		case ModeExternal:
			m_pAcq->SetParameter(CORACQ_PRM_INT_FRAME_TRIGGER_ENABLE, 0);
			m_pAcq->SetParameter(CORACQ_PRM_EXT_TRIGGER_ENABLE, CORACQ_VAL_EXT_TRIGGER_ON);
		//	m_pAcq->SetParameter(CORACQ_PRM_EXT_TRIGGER_FRAME_COUNT, nCount);
			break;
		}
	}
}


void CCameraControl_Sapera::SetTriggerSource(int nSource)
{
	m_nTriggerSource = nSource;

	if (m_pAcq && *m_pAcq) 
	{
		m_pAcq->SetParameter(CORACQ_PRM_EXT_TRIGGER_SOURCE, m_nTriggerSource);
	}
}

BOOL CCameraControl_Sapera::SetExposureTime(double dValue)
{
	if (m_nTriggerMode==ModeFreeRun) return FALSE;

	if (m_pAcq && *m_pAcq) 
	{
		return m_pAcq->SetParameter(CORACQ_PRM_TIME_INTEGRATE_DURATION, (UINT32)dValue); // us
	}

	return FALSE;
}

BOOL CCameraControl_Sapera::SetExposureAuto(BOOL bAuto)
{
	return FALSE;
}


BOOL CCameraControl_Sapera::GetExposureTime(double& dValue)
{
	if (m_nTriggerMode==ModeFreeRun) return FALSE;

	if (m_pAcq && *m_pAcq) 
	{
		UINT nTime = 0;
		BOOL bResult = m_pAcq->GetParameter(CORACQ_PRM_TIME_INTEGRATE_DURATION, &nTime); // us
		dValue = (double)nTime;
		return TRUE;
	}

	return FALSE;
}