#include "StdAfx.h"
#include "RadientControl.h"
#include "FrameBufferController.h"

MIL_ID		g_MilApplication_Radient	= M_NULL;	/* Application identifier.  */
int			g_nGrabberCount_Radient		= 0;		// grabber count

//==========================================================================================================================================================================
// Grabber Radient
CGrabberRadient::CGrabberRadient()
{
	m_nEndFrameIdx = m_nStartFrameIdx = 0;
	m_nSetBufferIdx = 0;
	m_nScanIndex = 0;
	m_nAllocatedGrabBufSize = 0;	
	m_isGrabbing = FALSE;
	m_isLiveGrab = FALSE;
	m_pFrameBuffer = NULL;	
		
	bUART_Connect[0] = FALSE;
	bUART_Connect[1] = FALSE;
}

CGrabberRadient::~CGrabberRadient()
{
	if(m_pFrameBuffer != NULL)
		delete m_pFrameBuffer;
	m_pFrameBuffer = NULL;
}

BOOL CGrabberRadient::Initialize(void *pParam, int *pErrorCode,int iBoard)
{
	_GRABBER_INIT_PARAM_ *pParameter = (_GRABBER_INIT_PARAM_ *)pParam;

	if(NULL != pParameter)
	{
		m_Param = *pParameter;		
		
	//	return TRUE;

		CString			strDCF;
		strDCF = m_Param.cDCFPath;

		CString strTmp;		

		if(g_nGrabberCount_Radient == 0)
		{
			MappAlloc(M_NULL,M_DEFAULT, &g_MilApplication_Radient);
		}		

		g_nGrabberCount_Radient++;				

		MsysAlloc(M_SYSTEM_RADIENTEVCL, m_Param.nBoardIdx, M_DEFAULT, &m_MilSystem);
		//MsysAlloc(M_DEFAULT, MIL_TEXT("M_DEFAULT"), m_Param.nBoardIdx, M_DEFAULT, &m_MilSystem);
		if(CheckLastError())
			return FALSE;		
		
		MdigAlloc(m_MilSystem  , m_Param.nBoardCh , strDCF, M_DEFAULT, &m_MilDigitizer);
		if(CheckLastError())
			return FALSE;

		for(int j = 0; j < BUFFERING_SIZE_MAX ;j++)
		{
			MbufAlloc2d(m_MilSystem, m_Param.nFrameWidth, m_Param.nFrameHeight, 8+M_UNSIGNED, M_IMAGE+M_GRAB, &m_Milbufgrab[j]);
		}		
		if(CheckLastError())
			return FALSE;

		/*
		INT nExposureTimer = m_Param.nExposure*1000;
		INT nExposureTimerDelay = m_Param.nExposureDelay*1000;

		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME+M_TIMER1,  nExposureTimer);                        //10us
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME_DELAY+M_TIMER1,  nExposureTimerDelay);                 //10us

		if(m_Param.nImgFlipX == 1)
			SetImageFlipX(TRUE);
		else
			SetImageFlipX(FALSE);
		*/

		//MdigControl(m_MilDigitizer,M_GRAB_MODE   , M_ASYNCHRONOUS);
		MdigControl(m_MilDigitizer,M_GRAB_TIMEOUT, M_INFINITE);
		if(CheckLastError())
			return FALSE;
		
		m_DigitizerStatus.status = M_STOP;	
		
	}
	else
		return FALSE;

	return TRUE;
}

BOOL CGrabberRadient::SetImageFlipX(BOOL bOn)
{
	if(bOn == TRUE)
		MdigControl(m_MilDigitizer, M_GRAB_DIRECTION_X, M_REVERSE);
	else
		MdigControl(m_MilDigitizer, M_GRAB_DIRECTION_X, M_FORWARD);

	return TRUE;
}

BOOL CGrabberRadient::CheckLastError()
{
	BOOL bReturn = FALSE;

	MIL_INT nErrorCode; 
	CString strMsg;

	if(MappGetError(M_GLOBAL, &nErrorCode))
	{
		int	iCam = m_Param.nCameraIdx;	
		int	iScan = m_Param.nCameraScan;
		int	iBoard = m_Param.nBoardIdx;
		int	iBoardCh = m_Param.nBoardCh;
		
		strMsg.Format(_T("[Board:%d,ch %d] [Camera:%d,Scan %d] MIL Error Code : %d"), iBoard,iBoardCh,iCam,iScan, nErrorCode);
		g_pLog->DisplayMessage(strMsg);	
		
		bReturn = TRUE;
	}	
	else
		bReturn = FALSE;

	return bReturn;
}

BOOL CGrabberRadient::InitializeBuffer(void *pParam)
{
	_GRABBER_INIT_PARAM_ *pParameter = (_GRABBER_INIT_PARAM_ *)pParam;

	BOOL		bRet = TRUE;
	if(NULL != pParameter)
	{
		m_Param = *pParameter;

		bRet = CreateGrabBuffer(m_Param.nScanCount,m_Param.nGrabBufCount,m_Param.nFrameWidth,m_Param.nFrameHeight);
	}

	return bRet;
}

BOOL CGrabberRadient::Deinitialize(void)
{	
	if (IsGrabbing())
		GrabScanStop();

	g_nGrabberCount_Radient--;

	for(int i = 0; i < BUFFERING_SIZE_MAX ;i++)
	{
		MbufFree(m_Milbufgrab[i]);
	}		

	MdigFree(m_MilDigitizer);	
	
	MsysFree(m_MilSystem);

	if(g_nGrabberCount_Radient == 0)
		MappFree(g_MilApplication_Radient);

	return TRUE;
}

BOOL CGrabberRadient::GrabLiveStart(int nExposure)
{
	if (IsGrabbing())
	{
		g_pLog->DisplayMessage(_T("Start Live Acq : IsGrabbing -> Stop Acq %d"), m_nEndFrameIdx);
		GrabScanStop();
		Sleep(100);				
	}

	m_nStartFrameIdx = 0;
	m_nEndFrameIdx = 0;
	m_nSetBufferIdx = -1;
	m_nScanIndex = 0;	

	if(m_DigitizerStatus.status == M_STOP)
	{				
		m_DigitizerStatus.status			= M_FREE_START;
		m_DigitizerStatus.nCount			= 0;
		m_DigitizerStatus.nIndex			= m_Param.nCameraScan;					

		MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);				
	}

	m_isGrabbing = TRUE;
	m_isLiveGrab = TRUE;
	g_pLog->DisplayMessage(_T("Start Live Acq"));

	return TRUE;
}

BOOL CGrabberRadient::GrabScanStart(int iScan, BOOL bFreeRun, int nPeriod, int nExposure, BOOL bAuto)
{	
	if (IsGrabbing())
	{
		g_pLog->DisplayMessage(_T("Start Acq : IsGrabbing -> Stop Acq %d"), m_nEndFrameIdx);
		GrabScanStop();
		Sleep(100);
	}

	m_nStartFrameIdx = 0;
	m_nEndFrameIdx = 0;
	m_nSetBufferIdx = -1;
	m_nScanIndex = iScan;

	if(bAuto == TRUE)
	{
		int nDigitizer = 0;

		if(bFreeRun == FALSE)
		{
			SetTriggerMode(TRUE);

			/* Start the processing. The processing function is called for every frame grabbed. */
			if(m_DigitizerStatus.status == M_STOP)
			{				
				m_DigitizerStatus.status			= M_START;
				m_DigitizerStatus.nCount			= 0;
				m_DigitizerStatus.nIndex			= iScan;				
				
				MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackHookFunction, this);				
			}
		}
		else
		{
			if(m_DigitizerStatus.status == M_STOP)
			{				
				m_DigitizerStatus.status			= M_FREE_START;
				m_DigitizerStatus.nCount			= 0;
				m_DigitizerStatus.nIndex			= iScan;				

				MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);				
			}
		}

		m_isGrabbing = TRUE;
		m_isLiveGrab = FALSE;
	}
	else
	{
		SimulationGrab(iScan);
	}	

	g_pLog->DisplayMessage(_T("Start Acq : %d"), iScan);

	return TRUE;
}

void CGrabberRadient::SimulationGrab(int iScan)
{
	if(m_pFrameBuffer == NULL)
		return;
		
	int			nFrameCnt = m_pFrameBuffer->GetFrameCount();

	m_nEndFrameIdx = nFrameCnt;
	m_nSetBufferIdx = nFrameCnt -1;
	
	for(int i=0;i<nFrameCnt;i++)
	{
		SetInsertFrame(iScan,i);
	}
}

BOOL CGrabberRadient::GrabScanStop(void)
{
	g_pLog->DisplayMessage(_T("%d StopAcq : Scan %d, Grab %d, End %d"), m_Param.nBoardIdx,m_nScanIndex,m_nSetBufferIdx, m_nEndFrameIdx);
	
	CString strMsg;
	
	if( m_DigitizerStatus.status == M_START)
	{
		MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_STOP, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackHookFunction, this);
		m_DigitizerStatus.nIndex	= m_nScanIndex;
		m_DigitizerStatus.status	= M_STOP;				
	}	
	else if(m_DigitizerStatus.status == M_FREE_START)
	{
		MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_STOP, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);
		m_DigitizerStatus.nIndex	= m_nScanIndex;
		m_DigitizerStatus.status	= M_STOP;		
	}
	
	m_isGrabbing = FALSE;
	m_isLiveGrab = FALSE;

	return TRUE;
}

BOOL CGrabberRadient::IsGrabbing(void)
{
	return m_isGrabbing;
}

int CGrabberRadient::IsAcqFrame(int nFrameNo, int nThreadIdx)
{
	return m_nSetBufferIdx - nFrameNo;		
}

LPBYTE	CGrabberRadient::GetFrameHeaderLine(int iScan,int nLine, BOOL* bSuccess)
{	
	if(m_pFrameBuffer == NULL)
		return NULL;

	return m_pFrameBuffer->GetFrameHeaderLine(iScan,nLine);
}

LPBYTE CGrabberRadient::GetFrameHeader(int iScan,int nFrameNo, BOOL* bRet)
{		
	if(m_pFrameBuffer == NULL)
		return NULL;

	return m_pFrameBuffer->GetFrameBuferHeader(iScan,nFrameNo);
}

BOOL CGrabberRadient::GetSmallImage(int iScan,LPBYTE lpIn, int nXStart, int nYStart, int nXSize, int nYSize, BOOL bMustMapping) 
{
	int nBufSizeX = m_Param.nFrameWidth;
	int nBufSizeY = m_Param.nFrameHeight;

	if (nXStart < 0 || nYStart < 0)
		return FALSE;
	if (nXStart + nXSize > nBufSizeX)
		return FALSE;
	if (nYStart + nYSize > nBufSizeY* GetEndFrameIdx())
		return FALSE;
	
	// 矫累 橇饭烙 锅龋客 场 橇饭烙 锅龋.
	int nStartFrameNo = nYStart / nBufSizeY;
	int nEndFrameNo = (nYStart + nYSize) / nBufSizeY;
	LPBYTE	lpHeadAddr = GetFrameHeader(iScan,nStartFrameNo);
	if (!lpHeadAddr)
	{
		return FALSE;
	}
	LPBYTE lpStart = lpHeadAddr + (nYStart % nBufSizeY) * nBufSizeX + nXStart;
	
	int nLine = 0;
	for (int i = 0; i < nYSize; i++)
	{
		memcpy(lpIn + i * nXSize, lpStart + nLine * nBufSizeX, nXSize);
		if (nStartFrameNo <= nEndFrameNo && (nYStart + i + 1) % nBufSizeY  == 0)
		{
			// 捞固瘤甫 蝶郴具窍绰 康开捞 MemFrameNo 版拌俊 吧媚乐绰 版快 贸府.
			lpHeadAddr = GetFrameHeader(iScan,++nStartFrameNo);
			lpStart = lpHeadAddr + nXStart;
			nLine = 0;
		}
		else
			nLine++;
	}
	
	return TRUE;
}

void CGrabberRadient::SetSimulFrame(int nFrame)
{
// 	if(nFrame == 0)
// 	{
// 		for(int i = 0; i < g_pBase->m_nProcessMargin; i++)
// 			SetSimulBuffer(i, m_nScanIndex % 2 == 1);
// 	}
// 
// 	m_nEndFrameIdx = CHKMIN(GetGrabFrameNo(m_nScanIndex), nFrame + g_pBase->m_nProcessMargin + 1);
// 	SetSimulBuffer(m_nEndFrameIdx - 1, m_nScanIndex % 2 == 1);
// 
// 	if(GetParents() != NULL)
// 		GetParents()->PostMessage(UM_IMAGE_GRAB, m_nEndFrameIdx - 1,NULL);
}

BOOL CGrabberRadient::Processing(long HookType, MIL_ID HookId)
{
	if(m_pFrameBuffer == NULL)
		return FALSE;
	
	MIL_ID ModifiedImage = 0;

	m_nEndFrameIdx++;			//Count
	m_nSetBufferIdx++;		//index

	if (m_nEndFrameIdx > g_pStatus->GetGrabFrameCount(m_nScanIndex))
	{
		GrabScanStop();		
		g_pStatus->SetGrabEnd(m_nScanIndex);
		g_pLog->DisplayMessage(_T("%d Over Grab Count : Stop Grab[%d][%d] - %d"), m_Param.nBoardIdx, m_nScanIndex, m_nEndFrameIdx,g_pStatus->GetGrabFrameCount(m_nScanIndex));
		return TRUE;
	}

	if (m_nSetBufferIdx > m_pFrameBuffer->GetFrameCount())
	{
		GrabScanStop();		
		g_pStatus->SetGrabEnd(m_nScanIndex);
		g_pLog->DisplayMessage(_T("%d Over Grab Buffer Stop Grab[%d][%d] - %d"), m_Param.nBoardIdx, m_nScanIndex, m_nEndFrameIdx,m_pFrameBuffer->GetFrameCount());
		return TRUE;
	}

	LPBYTE		pBuffer = m_pFrameBuffer->GetFrameBuferHeader(m_nScanIndex,m_nSetBufferIdx);
	if(pBuffer == NULL)
	{
		GrabScanStop();		
		g_pStatus->SetGrabEnd(m_nScanIndex);
		g_pLog->DisplayMessage(_T("%d Over Grab Buffer Stop Grab[%d][%d] - %d"), m_Param.nBoardIdx, m_nScanIndex, m_nEndFrameIdx,m_pFrameBuffer->GetFrameCount());
		return TRUE;
	}

	MdigGetHookInfo(HookId, M_MODIFIED_BUFFER+M_BUFFER_ID, &ModifiedImage);
	MbufControl(ModifiedImage, M_LOCK, M_DEFAULT);	
	MbufGet2d(ModifiedImage,0,0,m_Param.nFrameWidth,m_Param.nFrameHeight,pBuffer);
	MbufControl(ModifiedImage, M_UNLOCK, M_DEFAULT);	
			

	SetInsertFrame(m_nScanIndex,m_nSetBufferIdx);

	return TRUE;
}

long MFTYPE CGrabberRadient::CallbackHookFunction(long HookType, MIL_ID HookId, void MPTYPE *HookDataPtr)
{
	if(GetThreadPriority(GetCurrentThread()) != THREAD_PRIORITY_HIGHEST)
		SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

	CGrabberRadient	*pRadient = (CGrabberRadient*)HookDataPtr;

	pRadient->Processing(HookType,HookId);	

	return 0;
}

long MFTYPE CGrabberRadient::CallbackFreeRunFunction(long HookType, MIL_ID HookId, void MPTYPE *HookDataPtr)
{
	if(GetThreadPriority(GetCurrentThread()) != THREAD_PRIORITY_HIGHEST)
		SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

	CGrabberRadient	*pRadient = (CGrabberRadient*)HookDataPtr;

	if(pRadient->m_isLiveGrab == TRUE)		// Live Grab 矫.
	{
		pRadient->m_nSetBufferIdx = 0;

		LPBYTE		pBuffer = pRadient->m_pFrameBuffer->GetFrameBuferHeader(pRadient->m_nScanIndex,pRadient->m_nSetBufferIdx);
		if(pBuffer == NULL)
		{
			pRadient->GrabScanStop();		
			g_pStatus->SetGrabEnd(pRadient->m_nScanIndex);
			g_pLog->DisplayMessage(_T("%d Over Grab Buffer Stop Grab[%d][%d] - %d"), pRadient->m_Param.nBoardIdx, pRadient->m_nScanIndex, pRadient->m_nEndFrameIdx,pRadient->m_pFrameBuffer->GetFrameCount());
			return TRUE;
		}

		MIL_ID ModifiedImage = 0;
		MdigGetHookInfo(HookId, M_MODIFIED_BUFFER+M_BUFFER_ID, &ModifiedImage);
		MbufControl(ModifiedImage, M_LOCK, M_DEFAULT);	
		MbufGet2d(ModifiedImage,0,0,pRadient->m_Param.nFrameWidth,pRadient->m_Param.nFrameHeight,pBuffer);
		MbufControl(ModifiedImage, M_UNLOCK, M_DEFAULT);	
		
		/*
		int			iGrab = pRadient->m_nSetBufferIdx%pRadient->m_Param.nGrabBufCount;
		MbufGet(pRadient->m_MilImageChild[iGrab],pBuffer);
		*/

		return TRUE;
	}	

	return 0;
}

BOOL CGrabberRadient::CreateGrabBuffer(int nScanCount,int nBufSize, int nBufSizeX, int nBufSizeY)
{
	SIZE_T tempBufferSize= nBufSize;
	SIZE_T tempFrmCX = nBufSizeX;
	SIZE_T tempFrmCY = nBufSizeY;
	SIZE_T TotalBufferSize= tempBufferSize*tempFrmCX*tempFrmCY;	
	m_nAllocatedGrabBufSize = nBufSize;	

	if(m_pFrameBuffer != NULL)
		delete m_pFrameBuffer;
	m_pFrameBuffer = NULL;

	m_pFrameBuffer = new CFrameBufferController;

	if(TRUE == m_pFrameBuffer->CreateBuffer(m_Param.nCameraIdx,nBufSizeX ,nBufSizeY,nBufSize, nScanCount))
	{		
		g_pLog->DisplayMessage(_T("Create Buffer success!:Id[%d],Frame[%d,%d],Cnt[%d]"),m_Param.nCameraIdx,nBufSizeX,nBufSizeY,nBufSize);		
	}
	else
	{
		g_pLog->DisplayMessage(_T("Create Buffer Fail!:Id[%d],Frame[%d,%d],Cnt[%d]"),m_Param.nCameraIdx,nBufSizeX,nBufSizeY,nBufSize);
		return FALSE;
	}

	return TRUE;
}

void CGrabberRadient::ClearBuffer()
{
	if(m_pFrameBuffer != NULL)
		m_pFrameBuffer->ClearBuffer();
}

void CGrabberRadient::ClearGrabIdx()
{
	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();

	g_pLog->DisplayMessage(_T("Board : %d Clear.."), m_lBord);

	m_dqCallbackFrame.clear();
	MyLock.Unlock();
}

BOOL CGrabberRadient::SetInsertFrame(int iScan,int iFrame)
{
	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();

	stFrameIndex		stFrame(iScan,iFrame);
	m_dqCallbackFrame.push_back(stFrame);
	MyLock.Unlock();

	return TRUE;
}

BOOL CGrabberRadient::FindGrabIdx(int iScan,int iFrame)
{
	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();

	BOOL				bRet = FALSE;
	stFrameIndex		stFrame;
	for(dqGrabIdxIt it=m_dqCallbackFrame.begin();it!=m_dqCallbackFrame.end();it++)
	{
		stFrame = *it;

		if(stFrame.nScanIdx == iScan)
		{
			if(stFrame.nFrameIdx < iFrame)
				bRet = TRUE;
		}
	}
	MyLock.Unlock();

	return bRet;
}

int CGrabberRadient::GetGrabFrameCount()
{
	return (int)m_dqCallbackFrame.size();
}

stFrameIndex CGrabberRadient::GetGrabFrameNoRemove()
{
	stFrameIndex stPop(-1, -1);	

	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();
	if(IsHasGrabFrame() == FALSE)
	{
		MyLock.Unlock();
		return stPop;
	}

	stPop = m_dqCallbackFrame.front();	

	TRACE("Pop Frame Lock[%d]\r\n", stPop.nFrameIdx);
	MyLock.Unlock();
	return stPop;
}

stFrameIndex CGrabberRadient::GetGrabFrame()
{
	stFrameIndex stPop(-1, -1);	

	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();
	if(IsHasGrabFrame() == FALSE)
	{
		MyLock.Unlock();
		return stPop;
	}

	stPop = m_dqCallbackFrame.front();
	m_dqCallbackFrame.pop_front();

	TRACE("Pop Frame Lock[%d]\r\n", stPop.nFrameIdx);
	MyLock.Unlock();
	return stPop;
}

BOOL CGrabberRadient::IsHasGrabFrame()
{
	return !m_dqCallbackFrame.empty();
}

BOOL CGrabberRadient::SetTriggerMode( BOOL bExTrigger )
{	
	INT nExposureTimer = m_Param.nExposure*1000;
	INT nExposureTimerDelay = m_Param.nExposureDelay*1000;

	if(bExTrigger == TRUE)	// Trigger
	{
		/*
		MdigControl(m_MilDigitizer, M_CAMERALINK_CC1_SOURCE, M_GRAB_EXPOSURE+M_TIMER1);
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE+M_TIMER1, M_ENABLE);
		//MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_SOURCE+M_TIMER1, nHWPort);
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME+M_TIMER1,  nExposureTimer);                        //10us
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME_DELAY+M_TIMER1,  nExposureTimerDelay);                 //10us
		*/
	}
	else		// Live
	{
		/*
		MdigControl(m_MilDigitizer, M_CAMERALINK_CC1_SOURCE, M_GRAB_EXPOSURE+M_TIMER1);
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE+M_TIMER1, M_ENABLE);
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_SOURCE+M_TIMER1, M_CONTINUOUS);                      // Periodic 脚龋 牢啊
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME+M_TIMER1, nExposureTimer);                        //10000ns
		MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME_DELAY+M_TIMER1,  nExposureTimerDelay);                 //10000ns
		*/
	}

	return TRUE;
}