#include "StdAfx.h"
#include "SapControl.h"

#define	FRAME_HEAD_MARKER	0x55AAFF00
#define	FRAME_TAIL_MARKER	0x00FFAA55

CSapControl::CSapControl(void)
{
	m_nEndFrameIdx = m_nStartFrameIdx = 0;
	m_nSetBufferIdx = 0;
	m_nScanIndex = 0;
	m_nAllocatedGrabBufSize = 0;	
	m_nBoardID = 0;
	m_isGrabbing = FALSE;
	m_isLiveGrab = FALSE;
	m_pFrameBuffer = NULL;	

	int i;
	for (i = 0; i < MAX_BUFFER_COUNT; i++)
	{
		m_pX64Buffer[i]	= NULL;
		m_hBuffer[i]	= CORHANDLE_NULL;
	}
	for(i = 0; i < MAX_FRAME_COUNT; i++)
		m_hFrame[i] = CORHANDLE_NULL;
}


CSapControl::~CSapControl(void)
{
	Deinitialize();

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

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

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

		CString			strDCF;
		strDCF = m_Param.cDCFPath;

		if (!GetServer())
			return INITX64_FAIL_GETSERVER;

		if (!CreateAcq())
			return INITX64_FAIL_CREATEACQ;

		if (!CreateCamAndVic())
			return INITX64_FAIL_CAMNVIC;

		if (!CreateBuffer(CORBUFFER_VAL_TYPE_SCATTER_GATHER))
			return INITX64_FAIL_CREATEBUFFER;

		if (!CreateXfer())
			return INITX64_FAIL_CREATEXFER;

		//	if (g_pBase->m_nCameraModel == 1 && !SetScanDirection(g_pBase->m_nCameraSensor))
		//		return INITX64_FAIL_TDIDIRECTION;

		//	int nBufferSize = g_pBase->m_nFrameWidth * g_pBase->m_nFrameHeight * g_pBase->m_nMemFrameNo;
		//	CORSTATUS status = DisplayStatus("CorBufferMapEx", CorBufferMapExEx(m_hBuffer, 0, nBufferSize, m_pX64Buffer));
		ClearBuffer();
		
	}
	else
		return FALSE;

	return TRUE;
}

BOOL CSapControl::ClearBuffer()
{
	__int32		tagHead = FRAME_HEAD_MARKER;
	__int32		tagTail = FRAME_TAIL_MARKER;
	UINT8		dir[4] = {1,1,1,1} ;
	
	for (int i = 0; i < m_Param.nGrabBufCount; i++)
	{
		for(int j = 0; j < m_Param.nGrabBufSize; j++)
		{
			if (DisplayStatus("CorBufferWriteDots"
				, CorBufferWriteDots(m_hBuffer[i]
			, 0
				, j * m_Param.nFrameHeight
				, dir, 4, &tagHead, 4)))
				return FALSE;
			if( DisplayStatus( "CorBufferWriteDots"
				, CorBufferWriteDots(m_hBuffer[i]
			, m_Param.nFrameWidth - 4
				, (j * m_Param.nFrameHeight) + (m_Param.nFrameHeight - 1)
				, dir, 4, &tagTail, 4)))
				return FALSE;
		}
	}

	return TRUE;
}

BOOL CSapControl::CreateXfer()
{
	// XferÇÚµé »ý¼º
	if (DisplayStatus("CorXferNew", CorXferNew(m_hBoard, m_hAcq, *m_hBuffer, NULL, &m_hXfer)))
		return FALSE;

	CORXFER_DESC  xfer_desc ;
	xfer_desc.frame			= CORXFER_VAL_FRAME_NON_INTERLACED;
	//	xfer_desc.fieldOrder	= CORXFER_VAL_FIELD_ORDER_ANY_ORDER;
	xfer_desc.widthByte		= m_Param.nFrameWidth;
	xfer_desc.height		= m_Param.nFrameHeight;
	xfer_desc.incByte		= m_Param.nFrameWidth;

#ifdef FRAME_CALLBACK
	// Äݹé ÇÔ¼ö µî·Ï
	if (DisplayStatus("CorXferRegisterCallback"
		, CorXferRegisterCallback(m_hXfer
		, CORXFER_VAL_EVENT_TYPE_END_OF_FRAME
		, XferCallback, (void*)this)))
#else
	// Äݹé ÇÔ¼ö µî·Ï
	if (DisplayStatus("CorXferRegisterCallback"
		, CorXferRegisterCallback(m_hXfer
		, CORXFER_VAL_EVENT_TYPE_END_OF_NLINES + m_Param.nFrameHeight
		, XferCallback, (void*)this)))
#endif
		return FALSE;

	for(int i = 1; i < m_Param.nGrabBufCount; i++)
	{
		if (DisplayStatus("CorXferAppend", CorXferAppend(m_hXfer, m_hAcq, m_hBuffer[i], NULL)))
			return FALSE;

		// Äݹé ÇÔ¼ö µî·Ï
		if (DisplayStatus("CorXferRegisterCallback"
			, CorXferRegisterCallback(m_hXfer
			, CORXFER_VAL_EVENT_TYPE_END_OF_FRAME
			, XferCallback, (void*)this)))
			return FALSE;
	}

	if (DisplayStatus( "CorXferSetPrm",	CorXferSetPrm(m_hXfer, CORXFER_PRM_START_MODE, CORXFER_VAL_START_MODE_ASYNCHRONOUS)))
		return FALSE;

	if (DisplayStatus("CorXferConnect", CorXferConnectEx(m_hXfer,20000)))
		return FALSE;

	return TRUE;
}

BOOL CSapControl::CreateBuffer(UINT32 uiType)
{
	UINT32 nBufFormat = 0;		// Buffer format

	if (DisplayStatus("CorAcqGetPrm", CorAcqGetPrm(m_hAcq, CORACQ_PRM_OUTPUT_FORMAT, &nBufFormat)))
		return FALSE;

	//////////////////////////////////////////////////////////////////////////
	// Buffer ÇÒ´ç
	CORSTATUS st;
	int i;
	SIZE_T tempBufferSize= m_Param.nGrabBufSize;
	int nBufferrCount= m_Param.nGrabBufCount;	
	SIZE_T TotalBufferSize= tempBufferSize*m_Param.nFrameWidth * m_Param.nFrameHeight * m_Param.nGrabBufCount;
	SIZE_T nBufferSize = m_Param.nFrameWidth * m_Param.nFrameHeight * m_Param.nGrabBufSize;	

	m_pOneLargeBuffer= (BYTE*)VirtualAlloc(NULL, TotalBufferSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
	if(m_pOneLargeBuffer == NULL)
	{
		g_pLog->DisplayMessage(L"Err.X64Grab.CreaBuffer.VirtualAlloc[%d]", TotalBufferSize);
		return FALSE;
	}	

	for (i = 0; i <nBufferrCount; i++)
	{
		// Memory Address ÇÒ´ç.
		m_pX64Buffer[i] = (void*)(m_pOneLargeBuffer+ nBufferSize*i);		
		if (m_pX64Buffer[i])
		{
			st = CorBufferNewEx(m_hPC, m_Param.nFrameWidth, m_Param.nFrameHeight * m_Param.nGrabBufSize, nBufFormat, uiType, NULL, (ULONG_PTR) m_pX64Buffer[i], &m_hBuffer[i]);
			if (DisplayStatus("CorBuffeNew", st))
				return FALSE;
		}
		else
			return FALSE;
	}

	for(int j = 0; j < nBufferrCount; j++)
	{
		for(i =m_Param.nGrabBufSize * j; i < (m_Param.nGrabBufSize * (j + 1)); i++)
		{
			if(DisplayStatus("CorBufferNewChild", (CorBufferNewChild(m_hBuffer[j], 0, 
				(i - nBufferSize * j) * m_Param.nFrameHeight,
				m_Param.nFrameWidth, m_Param.nFrameHeight, &m_hFrame[i]))))
				return FALSE;
		}
	}

	return TRUE;
}

#include <cstringt.h>
// Create CAM and VIC objects
BOOL CSapControl::CreateCamAndVic()
{
	// Get a CAM handle
	if (DisplayStatus("CorCamNew", CorCamNew(m_hPC, &m_hCam)))
		return FALSE;

	// Get a VIC handle
	if (DisplayStatus("CorVicNew", CorVicNew(m_hPC, &m_hVic)))
		return FALSE;

	CString			strDCF,strVIC;
	strDCF = m_Param.cDCFPath;
	strVIC = m_Param.cDCFPath;

	// If a CAM file is specified, then read it.
	if (!strDCF.IsEmpty())
	{
		if(DisplayStatus("CorCamLoad", CorCamLoad(m_hCam, (PCSTR)strDCF.GetBuffer())))
			return FALSE;
	}

	// If a VIC file is specified, then read it
	if (!strVIC.IsEmpty())
	{
		if(DisplayStatus("CorVicLoad", CorVicLoad(m_hVic, (PCSTR)strVIC.GetBuffer())))
			return FALSE;		
	}

	// Update the acquisition module with the new CAM and VIC parameters
	if (DisplayStatus("CorAcqSetPrms", CorAcqSetPrms(m_hAcq, m_hVic, m_hCam, TRUE)))
		return FALSE;

	// ¼öÁýÇÒ ¿µ»óÀÇ Å©±â ÃßÃâ
	//	if (DisplayStatus("CorAcqGetPrm", CorAcqGetPrm(m_hAcq, CORACQ_PRM_SCALE_HORZ, &g_pBase->m_nFrameWidth)))
	//		return FALSE;

	//	if (DisplayStatus("CorAcqGetPrm", CorAcqGetPrm(m_hAcq, CORACQ_PRM_SCALE_VERT, &g_pBase->m_nFrameHeight)))
	//		return FALSE;

	return TRUE;
}

BOOL CSapControl::CreateAcq()
{
	// Get acquisition module handle
	UINT32 count ;
	if (DisplayStatus("CorAcqGetCount", CorAcqGetCount(m_hBoard, &count)))
		return FALSE;

	if (DisplayStatus("CorAcqGetHandle", CorAcqGetHandle(m_hBoard, 0, &m_hAcq)))
		return FALSE;

	return TRUE;
}

BOOL CSapControl::GetServer()
{
	//Get server selected
	char strName[50] = {0, };

	m_hPC= CorManGetServer();

	// Get handle to a Sapera enabled board
	UINT32 uiCount = 0;
	CorManGetServerCount(&uiCount);
	if (uiCount == 0)
		return FALSE;

	if (DisplayStatus("CorManGetServerByIndex", CorManGetServerByIndex(1, strName, &m_hBoard)))
		return FALSE;

	return TRUE;
}

CORSTATUS CSapControl::DisplayStatus( char *functionName, CORSTATUS status)
{	
	char statusMsg[ 256];
	CORSTATUS msgStatus = CORSTATUS_OK;

	if( status != CORSTATUS_OK)
	{
		msgStatus = CorManGetStatusText( status, statusMsg, 256, NULL, 0);
		if( msgStatus == CORSTATUS_OK)
		{
			g_pLog->DisplayMessage(_T("1Error: Function [%s] (module= 0x%lX status= 0x%lX info= 0x%lX) <%s>"),functionName, CORSTATUS_MODULE( status), CORSTATUS_ID( status), CORSTATUS_INFO( status), statusMsg);			
		}
		else
		{
			g_pLog->DisplayMessage(_T("2Error: Function [%s] (module= 0x%lX status= 0x%lX info= 0x%lX)"),functionName, CORSTATUS_MODULE( status), CORSTATUS_ID( status), CORSTATUS_INFO( status));			
		}
		
		return status;
	}

	return( status);
}

BOOL CSapControl::Deinitialize()
{
	BOOL result = TRUE;

	result &= DestroyBuffer();
	result &= DestroyCamAndVic();
	result &= DestroyXfer();

	return result;
}

BOOL CSapControl::DestroyBuffer()
{
	// Release the buffer handles	
	if(m_pOneLargeBuffer != NULL)
		VirtualFree(m_pOneLargeBuffer, 0, MEM_RELEASE);
	m_pOneLargeBuffer= NULL;

	for (int i = 0; i < m_Param.nGrabBufCount; i++)
	{
		if (m_pX64Buffer[i])
		{
			m_pX64Buffer[i] = NULL;
		}

		if (VALIDATE_HANDLE_BUFFER(m_hBuffer[i]) == CORSTATUS_OK)
		{
			if (DisplayStatus("CorBufferFree", CorBufferFree(m_hBuffer[i])))
				return FALSE;

			m_hBuffer[i] = CORHANDLE_NULL;
		}
	}
	

	return TRUE;
}

// Destroy CAM and VIC objects
BOOL CSapControl::DestroyCamAndVic()
{
	// Release VIC handle
	if (VALIDATE_HANDLE_VIC(m_hVic) == CORSTATUS_OK)
	{
		if (DisplayStatus( "CorVicFree", CorVicFree(m_hVic)))
			return FALSE;

		m_hVic = CORHANDLE_NULL;
	}
	// Release CAM handle
	if (VALIDATE_HANDLE_CAM(m_hCam) == CORSTATUS_OK)
	{
		if (DisplayStatus( "CorCamFree", CorCamFree(m_hCam)))
			return FALSE;

		m_hCam = CORHANDLE_NULL;
	}

	return TRUE;
}

// Destroy Transfer object
BOOL CSapControl::DestroyXfer()
{
	// Deactivate the connection(s)
	if (VALIDATE_HANDLE_XFER(m_hXfer) == CORSTATUS_OK)
	{
		if( DisplayStatus("CorXferDisconnect", CorXferDisconnect(m_hXfer)))
			return FALSE;

		// Release the Xfer handle
		if (DisplayStatus("CorXferFree", CorXferFree(m_hXfer)))
			return FALSE;

		m_hXfer = CORHANDLE_NULL;
	}

	return TRUE;	
}

BOOL CSapControl::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 CSapControl::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;
}

BOOL CSapControl::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;	

	int nFrameCount = m_Param.nGrabBufCount / m_Param.nGrabBufSize;
	if (m_Param.nGrabBufCount % m_Param.nGrabBufSize > 0)
		nFrameCount++;
	nFrameCount += 4;

	if (DisplayStatus( "CorAcqSetPrm", CorAcqSetPrm(m_hAcq, CORACQ_PRM_EXT_TRIGGER_FRAME_COUNT, nFrameCount)))
		return FALSE;

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

	return TRUE;
}

BOOL CSapControl::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 nFrameCount = m_Param.nGrabBufCount / m_Param.nGrabBufSize;
		if (m_Param.nGrabBufCount % m_Param.nGrabBufSize > 0)
			nFrameCount++;
		nFrameCount += 4;

		if(bFreeRun == FALSE)
		{
			// µ¿±â ¿µ»óÈ®º¸ °æ¿ì 
			if( DisplayStatus( "CorAcqSetPrm", CorAcqSetPrm(m_hAcq, CORACQ_PRM_EXT_FRAME_TRIGGER_ENABLE, TRUE)))
				return FALSE;

			if (DisplayStatus( "CorAcqSetPrm", CorAcqSetPrm(m_hAcq, CORACQ_PRM_EXT_TRIGGER_FRAME_COUNT, nFrameCount)))
				return FALSE;
		}
		else
		{
			if (DisplayStatus( "CorAcqSetPrm", CorAcqSetPrm(m_hAcq, CORACQ_PRM_EXT_TRIGGER_FRAME_COUNT, nFrameCount)))
				return FALSE;
		}

		if (DisplayStatus("CorXferStart", CorXferStart(m_hXfer, CORXFER_CONTINUOUS)))
			return FALSE;

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

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

	return TRUE;
}

BOOL CSapControl::GrabScanStop(void)
{
	g_pLog->DisplayMessage(_T("%d StopAcq : Scan %d, Grab %d, End %d"), m_Param.nBoardIdx,m_nScanIndex,m_nSetBufferIdx, m_nEndFrameIdx);

	BOOL bRet = TRUE;
	if (m_bIsGrabbing)
	{
		g_pLog->DisplayMessage(L"StopAcq : Grab %d, End %d", m_nSetBufferIdx, m_nEndFrameIdx);

		//20141022 yjm abort ·Î ÇÏ¸é ´ÙÀ½ ±×·¦½Ã ÀÚ²Ùº¸µå°¡ »¸¾î¹ö¸°´Ù. ÀçºÎÆø¸ ÅëÇÔ..¾¾¹ã °³°í»ý¤Ñ¤Ñ¤»
		if (DisplayStatus("CorXferStop", CorXferStop(m_hXfer)))//if (DisplayStatus("CorXferStop", CorXferAbort(m_hXfer)))
		{
			g_pLog->DisplayMessage(L"CorXferAbort Fail. Grab %d, End %d", m_nSetBufferIdx, m_nEndFrameIdx);
			bRet = FALSE;
			//return FALSE;
		}

		if(DisplayStatus("CorXferWait", CorXferWait(m_hXfer, 200)))
		{
			g_pLog->DisplayMessage(L"CorXferWait 1 Fail. Grab %d, End %d", m_nSetBufferIdx, m_nEndFrameIdx);
			bRet = FALSE;
			//return FALSE;
		}

		if (DisplayStatus("CorXferAbort", CorXferAbort(m_hXfer)))
		{
			g_pLog->DisplayMessage(L"CorXferAbort Fail. Grab %d, End %d", m_nSetBufferIdx, m_nEndFrameIdx);
			bRet = FALSE;
			//return FALSE;
		}

		if(DisplayStatus("CorXferWait", CorXferWait(m_hXfer, 200)))
		{
			g_pLog->DisplayMessage(L"CorXferWait 2 Fail. Grab %d, End %d", m_nSetBufferIdx, m_nEndFrameIdx);
			bRet = FALSE;
			//return FALSE;
		}

		m_isGrabbing = FALSE;
		m_isLiveGrab = FALSE;
	}

	return bRet;
}

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

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

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

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

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

BOOL CSapControl::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;
}

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

void CSapControl::ClearGrabIdx()
{
	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();
	m_dqCallbackFrame.clear();
	MyLock.Unlock();
}

BOOL CSapControl::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;
}

stFrameIndex CSapControl::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 CSapControl::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 CSapControl::IsHasGrabFrame()
{
	return !m_dqCallbackFrame.empty();
}

void CSapControl::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 CSapControl::SetInsertFrame(int iScan,int iFrame)
{
	CSingleLock MyLock(&m_csIdxLock);
	MyLock.Lock();

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

	return TRUE;
}

LPBYTE CSapControl::GetGrabFrameHeader(int nFrameNo)
{
	LPBYTE lpBuffer = NULL;

	// À̹ÌÁö¸¦ ÂïÀº ÀûÀÌ ¾ø´Â °æ¿ì´Â ¹öÆÛ¸¦ ¸®ÅÏÇÑ´Ù.
	if (m_nStartFrameIdx == 0 && m_nEndFrameIdx == 0)
	{
		if (nFrameNo >= 0 && nFrameNo <	g_pBase->m_pMemFrameNo[m_Param.nCameraIdx])
		{
			LPBYTE uiHeadAddr;
			CorBufferGetPrm(m_hBuffer[nFrameNo / m_Param.nGrabBufSize], CORBUFFER_PRM_ADDRESS, &uiHeadAddr);
			lpBuffer = (LPBYTE)(uiHeadAddr + ((nFrameNo % m_Param.nGrabBufSize) * m_Param.nFrameWidth * m_Param.nFrameHeight));
		}
		else
			lpBuffer = NULL;
	}
	else	// À̹ÌÁö¸¦ ÂïÀº °æ¿ì´Â Frame No¸¦ È®ÀÎÇÏ¿© ¹öÆÛ¸¦ ¸®ÅÏÇÑ´Ù.
	{
		if (nFrameNo >= m_nStartFrameIdx && nFrameNo < m_nEndFrameIdx)
		{
			int nBufferNo = (nFrameNo / m_Param.nGrabBufSize) % m_Param.nGrabBufCount;			
			LPBYTE uiHeadAddr;
			CorBufferGetPrm(m_hBuffer[nBufferNo], CORBUFFER_PRM_ADDRESS, &uiHeadAddr);
			lpBuffer = reinterpret_cast<LPBYTE>(uiHeadAddr + ((nFrameNo % m_Param.nGrabBufSize) * m_Param.nFrameWidth * m_Param.nFrameHeight));
		}
		else
			lpBuffer = NULL;
	}

	return lpBuffer;
}

CORSTATUS CCONV CSapControl::XferCallback(void *context, UINT32 eventType, UINT32 eventCount)
{
	CSapControl* pX64 = (CSapControl*)context;

	pX64->m_nEndFrameIdx++;			//Count
	pX64->m_nSetBufferIdx++;		//index	

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

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

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

	LPBYTE lpBuffer = pX64->GetGrabFrameHeader(pX64->m_nSetBufferIdx);
	if(lpBuffer == NULL)
		return FALSE;

	memcpy(pBuffer, lpBuffer, pX64->m_Param.nFrameWidth * pX64->m_Param.nFrameHeight);

	pX64->SetInsertFrame(pX64->m_nScanIndex,pX64->m_nSetBufferIdx);

	return CORSTATUS_OK;
}