// GrabContinuous.c

/* @brief: This example shows users how to use IKapC and IKapBoard libraries to grab images continuously with CoaXPress camera. */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "IKapBoard.h"
#include "IKapC.h"

// Pre-defined.
#define HANDLE void*
#define CALLBACK 

// The number of frames requested by buffer.
#define BOARD_FRMAE_COUNT 5

// Camera device handle.
ITKDEVICE g_hCamera = NULL;

// Frame grabber device handle.
HANDLE g_hBoard = (void*)-1;

// File name of configuration file.
char configFilename[256] = "";

// Current frame index.
int g_nCurFrameIndex = 0;

/* @brief: Determine whether the IKapBoard function is called successfully.
 * @param[in] errc: Function return value. */
#define CHECK_IKAPBOARD(errc) if (errc != 1) printIKapBoardErrorAndExit()

/* @brief: Determine whether the IKapC function is called successfully.
 * @param[in] errc: Function return value. */
#define CHECK_IKAPC(errc) if (errc != ITKSTATUS_OK) printIKapCErrorAndExit(errc)

/* @brief: Print IKapBoard error message and exit the program. */
void printIKapBoardErrorAndExit();

/* @brief: Print IKapC error message and exit the program.
 * @param[in] errc: Function return value. */
void printIKapCErrorAndExit(ITKSTATUS errc);

/* @brief: Users enter Enter to exit the program. */
void pressEnterToExit(void);

/* @brief: Configure camera device.
 * @param[out] hCamera: Camera device handle.
 * @param[out] hBoard: Frame grabber device handle. */
void ConfigureCamera(ITKDEVICE *hCamera, HANDLE *hBoard);

/* @brief: Configure frame grabber device.
 * @param[in] hCamera: Camera device handle.
 * @param[in] hBoard: Frame grabber device handle. */
void ConfigureFrameGrabber(ITKDEVICE hCamera, HANDLE hBoard);

/* @brief: Start grabbing images.
 * @param[in] hCamera: Camera device handle.
 * @param[in] hBoard: Frame grabber device handle. */
void StartGrabImage(ITKDEVICE hCamera, HANDLE hBoard);

/* @brief: Unregister callback functions. */
void UnRegisterCallback();

/* @brief: This function is registered as a callback function. When starting grabbing images, the function will be called.
 * @param[in] pContext: Input parameter. */
void CALLBACK OnGrabStart(void *pContext);

/* @brief: This function is registered as a callback function. When a frame of image grabbing ready, the function will be called.
 * @param[in] pContext: Input parameter. */
void CALLBACK OnFrameReady(void *pContext);

/* @brief: This function is registered as a callback function. When grabbing images time out, the function will be called.
 * @param[in] pContext: Input parameter. */
void CALLBACK OnTimeout(void *pContext);

/* @brief: This function is registered as a callback function. When grabbing frame lost, the function will be called.
 * @param[in] pContext: Input parameter. */
void CALLBACK OnFrameLost(void *pContext);

/* @brief: This function is registered as a callback function. When stopping grabbing images, the function will be called.
 * @param[in] pContext: Input parameter. */
void CALLBACK OnGrabStop(void *pContext);

int main()
{
	// Return value of IKapC functions.
	ITKSTATUS res = ITKSTATUS_OK;

	// Return value of IKapBoard functions.
	int ret = IK_RTN_OK;

	// Initialize IKapC runtime environment.
	res = ItkManInitialize();
	CHECK_IKAPC(res);

	// Configure camera device.
	ConfigureCamera(&g_hCamera, &g_hBoard);

	// Configure frame grabber device.
	ConfigureFrameGrabber(g_hCamera, g_hBoard);

	// Start grabbing images.
	StartGrabImage(g_hCamera, g_hBoard);

	// Wait for grabbing images finished.
	getchar();

	// Stop grabbing images.
	ret = IKapStopGrab(g_hBoard);
	CHECK_IKAPBOARD(ret);

	// Unregister callback functions.
	UnRegisterCallback();

	// Close frame grabber device.
	ret = IKapClose(g_hBoard);
	CHECK_IKAPBOARD(ret);

	// Release IKapC runtime environment.
	ItkManTerminate();

	pressEnterToExit();
	return 0;
}

// Print IKapBoard error message and exit the program.
void printIKapBoardErrorAndExit()
{
	// Get error code message.
	IKAPERRORINFO errc;
	IKapGetLastError(&errc, 1);

	// Print error message.
	fprintf(stderr, "IKapBoard:Index: %d, error code:%04x\n", errc.uBoardIndex, errc.uErrorCode);

	pressEnterToExit();
	exit(EXIT_FAILURE);
}

// Print IKapC error message and exit the program.
void printIKapCErrorAndExit(ITKSTATUS errc)
{
	fprintf(stderr, "IKapC error code: %08X", errc);
	ItkManTerminate();
	pressEnterToExit();
	exit(EXIT_FAILURE);
}

// Configure camera device.
void ConfigureCamera(ITKDEVICE *hCamera, HANDLE *hBoard)
{
	ITKSTATUS res = ITKSTATUS_OK;
	uint32_t numCameras = 0;

	// Enumerate the number of available cameras. Before opening the camera, ItkManGetDeviceCount() function must be called.
	res = ItkManGetDeviceCount(&numCameras);
	CHECK_IKAPC(res);

	// When there is no connected cameras.
	if (numCameras == 0)
	{
		printf("No camera.\n");
		ItkManTerminate();
		pressEnterToExit();
		exit(EXIT_FAILURE);
	}

	// Open CoaXPress camera.
	for (uint32_t i = 0; i < numCameras; i++)
	{
		ITKDEV_INFO di;

		// Get camera device information.
		res = ItkManGetDeviceInfo(i, &di);
		printf("Using camera: serial: %s, name: %s, interface: %s.\n", di.SerialNumber, di.FullName, di.DeviceClass);

		// When the device is CoaXPress camera and the serial number is proper.
		if (strcmp(di.DeviceClass, "CoaXPress") == 0 && strcmp(di.SerialNumber, "") != 0)
		{
			ITK_CXP_DEV_INFO cxp_cam_info;
			IKAP_CXP_BOARD_INFO cxp_board_info;

			// Open camera.
			res = ItkDevOpen(i, ITKDEV_VAL_ACCESS_MODE_EXCLUSIVE, hCamera);
			CHECK_IKAPC(res);

			// Get CoaXPress camera device information.
			res = ItkManGetCXPDeviceInfo(i, &cxp_cam_info);
			CHECK_IKAPC(res);

			// Open frame grabber.
			memcpy(&cxp_board_info, &cxp_cam_info, sizeof cxp_cam_info);
			*hBoard = IKapOpenCXP(IKBoardPCIE, cxp_board_info.BoardIndex, cxp_board_info);
			if (*hBoard == (void*)-1)
				CHECK_IKAPC(IKStatus_OpenBoardFail);
		}
	}
}

// Configure frame grabber device.
void ConfigureFrameGrabber(ITKDEVICE hCamera, HANDLE hBoard)
{
	ITKSTATUS res = ITKSTATUS_OK;
	int ret = IK_RTN_OK;
	
	// Input load configuration address
	printf("Please input load configuration address, for example: ./GrabContinuous.vlcf\n");
	gets(configFilename);

	// Load configuration file.
    ret = IKapLoadConfigurationFromFile(hBoard, configFilename);
    CHECK_IKAPBOARD(ret);

	// Set frame count of buffer.
	ret = IKapSetInfo(hBoard, IKP_FRAME_COUNT, BOARD_FRMAE_COUNT);
	CHECK_IKAPBOARD(ret);

	// Set time out time.
	int timeout = -1;
	ret = IKapSetInfo(hBoard, IKP_TIME_OUT, timeout);
	CHECK_IKAPBOARD(ret);

	// Set grab mode.
	int grab_mode = IKP_GRAB_NON_BLOCK;
	ret = IKapSetInfo(hBoard, IKP_GRAB_MODE, grab_mode);
	CHECK_IKAPBOARD(ret);

	// Set transfer mode.
	int transfer_mode = IKP_FRAME_TRANSFER_SYNCHRONOUS_NEXT_EMPTY_WITH_PROTECT;
	ret = IKapSetInfo(hBoard, IKP_FRAME_TRANSFER_MODE, transfer_mode);
	CHECK_IKAPBOARD(ret);

	// Register callback functions.
	ret = IKapRegisterCallback(hBoard, IKEvent_GrabStart, OnGrabStart, hBoard);
	CHECK_IKAPBOARD(ret);
	ret = IKapRegisterCallback(hBoard, IKEvent_FrameReady, OnFrameReady, hBoard);
	CHECK_IKAPBOARD(ret);
	ret = IKapRegisterCallback(hBoard, IKEvent_FrameLost, OnFrameLost, hBoard);
	CHECK_IKAPBOARD(ret);
	ret = IKapRegisterCallback(hBoard, IKEvent_TimeOut, OnTimeout, hBoard);
	CHECK_IKAPBOARD(ret);
	ret = IKapRegisterCallback(hBoard, IKEvent_GrabStop, OnGrabStop, hBoard);
	CHECK_IKAPBOARD(ret);
}

// Start grabbing images.
void StartGrabImage(ITKDEVICE hCamera, HANDLE hBoard)
{
	ITKSTATUS res = ITKSTATUS_OK;
	int ret = IK_RTN_OK;

	res = ItkDevExecuteCommand(hCamera, "AcquisitionStop");
	CHECK_IKAPC(res);

	ret = IKapStartGrab(hBoard, 0);
	CHECK_IKAPBOARD(ret);

	res = ItkDevExecuteCommand(hCamera, "AcquisitionStart");
	CHECK_IKAPC(res);
}

// Unregister callback functions.
void UnRegisterCallback()
{
	int ret = IK_RTN_OK;

	ret = IKapUnRegisterCallback(g_hBoard, IKEvent_GrabStart);
	ret = IKapUnRegisterCallback(g_hBoard, IKEvent_FrameReady);
	ret = IKapUnRegisterCallback(g_hBoard, IKEvent_FrameLost);
	ret = IKapUnRegisterCallback(g_hBoard, IKEvent_TimeOut);
	ret = IKapUnRegisterCallback(g_hBoard, IKEvent_GrabStop);
}

// Users enter Enter to exit the program.
void pressEnterToExit(void)
{
	fprintf(stderr, "\nPress enter to exit.\n");
	while (getchar() != '\n');
}

// This function is registered as a callback function. When starting grabbing images, the function will be called.
void CALLBACK OnGrabStart(void *pContext)
{
	printf("Start grabbing image.\n");
}

// This function is registered as a callback function. When a frame of image grabbing ready, the function will be called.
void CALLBACK OnFrameReady(void *pContext)
{
	HANDLE hDev = (HANDLE)pContext;
	unsigned char* pUserBuffer = NULL;
	int nFrameSize = 0;
	int nFrameCount = 0;
	int nBufferIndex = g_nCurFrameIndex % BOARD_FRMAE_COUNT;;
	IKAPBUFFERSTATUS status;

	IKapGetInfo(hDev, IKP_FRAME_COUNT, &nFrameCount);
	IKapGetBufferStatus(hDev, nBufferIndex, &status);

	// When the buffer is full.
	if (status.uFull == 1)
	{
		// Get the size of a frame of image.
		IKapGetInfo(hDev, IKP_FRAME_SIZE, &nFrameSize);

		// Get the buffer address.
		IKapGetBufferAddress(hDev, nBufferIndex, (void**)&pUserBuffer);
	}
	
	printf("Grab %d frame ready.\n", ++g_nCurFrameIndex);
}

// This function is registered as a callback function. When grabbing images time out, the function will be called.
void CALLBACK OnTimeout(void *pContext)
{
	printf("Grab image timeout.\n");
}

// This function is registered as a callback function. When grabbing frame lost, the function will be called.
void CALLBACK OnFrameLost(void *pContext)
{
	printf("Grab frame lost.\n");
}

// This function is registered as a callback function. When stopping grabbing images, the function will be called.
void CALLBACK OnGrabStop(void *pContext)
{
	printf("Stop grabbing image.\n");
}