myvtm/Module/mod_livenessdetection/LivenessDetectionFSM.h

#ifndef LIVENESSDETECTIONFSM_H
#define LIVENESSDETECTIONFSM_H

#pragma once

#include "SpFSM.h"
#include <string>
#include "..\..\Other\libvideoqueue\libvideoqueue.h"
#include "LivenessDetection_def_g.h"

using namespace LivenessDetection;

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_STARTCAPTURE,
	USER_EVT_STARTCAPTURE_FINISHED,
	USER_EVT_STOPCAPTURE,
	USER_EVT_CAPTURE_FINISHED,
	USER_EVT_EXIT,
	USER_EVT_ERROR
};

class CLivenessDetectionFSM : public FSMImpl<CLivenessDetectionFSM>, public IFSMStateHooker
{
	friend LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
	friend class StartCaptureTask;
	friend class StopCaptureTask;
	friend class WaitCaptureFinishTask;
public:
	enum {s0, s1, s2};

	BEGIN_FSM_STATE(CLivenessDetectionFSM)
		FSM_STATE_ENTRY(s0, "Normal", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "StartCapturing", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Capturing", s2_on_entry, s2_on_exit, s2_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CLivenessDetectionFSM, s0)
		FSM_RULE_ENTRY(s0, s0, EVT_TIMER, 0)							// 计时器
		FSM_RULE_ENTRY(s0, s1, USER_EVT_STARTCAPTURE, 0)				// 启动捕获
		FSM_RULE_ENTRY(s1, s2, USER_EVT_STARTCAPTURE_FINISHED, 0)		// 启动捕获成功
		FSM_RULE_ENTRY(s1, s0, USER_EVT_STARTCAPTURE_FINISHED, 1)		// 启动捕获失败
		FSM_RULE_ENTRY(s2, s2, USER_EVT_STOPCAPTURE, 0)					// 停止捕获（人为结束）
		FSM_RULE_ENTRY(s2, s0, USER_EVT_CAPTURE_FINISHED, 0)			// 捕获完成（主动/被动）
	END_FSM_RULE()

public:

	CLivenessDetectionFSM(int fps,LPCTSTR videoqueue0name,LPCTSTR videoqueue1name,int videowidth,int videoheight);
	virtual ~CLivenessDetectionFSM();

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	virtual void OnStateTrans(int iSrcState, int iDstState);

	virtual void s0_on_entry();
	virtual void s0_on_exit();
	virtual unsigned int s0_on_event(FSMEvent* e);

	virtual void s1_on_entry();
	virtual void s1_on_exit();
	virtual unsigned int s1_on_event(FSMEvent* e);

	virtual void s2_on_entry();
	virtual void s2_on_exit();
	virtual unsigned int s2_on_event(FSMEvent* e);

	// 获取当前是否有活体任务
	bool GetHasLiveTask() const {return m_bHasLiveTask;}
	// 启动活体
	void StartLiveDetect(SpReqAnsContext<LivenessDetectionService_StartLivenessDetection_Req, LivenessDetectionService_StartLivenessDetection_Ans>::Pointer ctx);
	// 设置主动停止活体
	void SetActiveStopLiveDetect(SpReqAnsContext<LivenessDetectionService_StopLivenessDetection_Req, LivenessDetectionService_StopLivenessDetection_Ans>::Pointer ctx);
	// 报摄像头故障
	void NotifyCameraFault();

private:
	videoq_frame *videoframe0;
	videoq_frame *videoframe1;
	Clibvideoqueue *m_videoqueue0;
	Clibvideoqueue *m_videoqueue1;
	
	// 是否保存每次的活体结果
	BOOL m_bSaveLivenessResult;
	// 活体结果路径
	CSimpleStringA m_LivenessResultPath;
	// 当前是否已经有活体任务
	bool m_bHasLiveTask;
	// 是否主动停止活体
	bool m_bActiveStop;
	// look lower screen flag	add by ly at 2-17/01/20
	bool m_bLookLowerScreen;
	// 开始捕获捕获上下文
	SpReqAnsContext<LivenessDetectionService_StartLivenessDetection_Req, LivenessDetectionService_StartLivenessDetection_Ans>::Pointer m_StartCtx;
	// 主动停止捕获上下文
	SpReqAnsContext<LivenessDetectionService_StopLivenessDetection_Req, LivenessDetectionService_StopLivenessDetection_Ans>::Pointer m_StopCtx;
	int m_nFps;
	std::string m_VideoQueue0Name;
	std::string m_VideoQueue1Name;
	HANDLE m_hEventWait; // CreateEvent
	BOOL m_bStopCapture;
	CRITICAL_SECTION m_lock1; // for bitmap
	CRITICAL_SECTION m_lock2; // for camera thread
	HANDLE m_hEventTask; // task finish event	add by ly at 2017/01/20

private:
	// 启动活体检测消息窗口
	BOOL StartMsgHwnd(UINT nInterval);
	// 停止活体检测消息窗口
	BOOL StopMsgHwnd();
	void VideoInit(LPCTSTR videoqueue0name,LPCTSTR videoqueue1name);
	int GetVideoFrameSize(int&nWidth,int&nHeight);
	BOOL GetVideoFrameByCameraID( int CameraID, videoq_frame* Video, int flags );
	void FSleep(int ms);

public:
	UINT VideoCapture0();
	UINT VideoCapture1();
	UINT SingleCameraDetect();
	UINT LiveDetect();
	HANDLE m_hDetectThread;
	HANDLE m_hCameraThread0;
	HANDLE m_hCameraThread1;
	bool m_bThreadRun;
	bool m_bCameraThreadRun;
	BITMAP m_Bitmap0;
	BITMAP m_Bitmap1;
	BITMAP m_Bitmap0Disp;
	BITMAP m_Bitmap1Disp;
	bool m_bUpdateScreen;
	int m_nCaptureType;
	std::string m_ActionID;
	// 会话id
	CUUID m_uid;
	int m_nTime;
	bool m_bHasData0;
	bool m_bHasData1;
	int m_nImageSize;

protected:
	int m_nPassiveTimeLimit;
	int m_nActiveTimeLimit;
	int m_nLeastActiveShowTime;
	BOOL m_bLoosePassiveStrategy;    // 是否应用宽松的被动活体策略
	bool IsTimeOut();
	bool m_bTimeout;
	void UpdateTime(int nFrame);
	void DrawRect(RECT rect,BITMAP* pPic);

	int m_nLastFrame;
	int m_nSeconds;
	// 保存活体配置
	BOOL SaveLiveConfig(SpReqAnsContext<LivenessDetectionService_StartLivenessDetection_Req, LivenessDetectionService_StartLivenessDetection_Ans>::Pointer ctx);
	int StartLivenessDetection();
	void StopLivenessDetection();
};

struct StartCaptureTask : public ITaskSp
{
	CLivenessDetectionFSM *m_pFsm;
	StartCaptureTask(CLivenessDetectionFSM *f) : m_pFsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_STARTCAPTURE_FINISHED);
		e->param1 = m_pFsm->StartLivenessDetection();
		m_pFsm->PostEventFIFO(e);
	}
};

struct StopCaptureTask : public ITaskSp
{
	CLivenessDetectionFSM *m_pFsm;
	StopCaptureTask(CLivenessDetectionFSM *f) : m_pFsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_CAPTURE_FINISHED);
		m_pFsm->StopLivenessDetection();
		m_pFsm->PostEventFIFO(e);
	}
};

struct WaitCaptureFinishTask : public ITaskSp
{
	CLivenessDetectionFSM *m_pFsm;
	WaitCaptureFinishTask(CLivenessDetectionFSM *f) : m_pFsm(f) {}

	void Process()
	{
		m_pFsm->PostEventFIFO(new FSMEvent(USER_EVT_STOPCAPTURE));
		if (m_pFsm->m_hEventTask)
		{
			DWORD ret = WaitForSingleObject(m_pFsm->m_hEventTask,5000);
			if (ret != WAIT_OBJECT_0)
			{
				Dbg("[dbg] failed to wait hEventTask!");
			}
			else
			{
				Dbg("[dbg] succeeded to wait hEventTask!");
			}
			Dbg("[dbg] the last live task terminated!");
		}
		m_pFsm->m_StartCtx->Answer(Error_Succeed);
		m_pFsm->PostEventFIFO(new FSMEvent(USER_EVT_STARTCAPTURE));
	}
};


#endif