myvtm/Module/mod_mediacontroller/mod_mediacontroller.h

#pragma once

#include "SpBase.h"
#include "SpIni.h"

#include "MediaController_server_g.h"
#include "MediaController_msg_g.h"
#include "ExternalCameraMsg.h"

#include "../mod_selfchecker/SelfChecker_client_g.h"
#include "../mod_selfchecker/SelfChecker_def_g.h"
#include "../include/ModuleMix.h"
#include "../include/EventCode.h"

// id:0x208
#include "../mod_assistantchannel/AssistantChannel_client_g.h"
#include "../mod_assistantchannel/chan_protocol.h"

#include "../mod_ScannerSet/ScannerSet_client_g.h"
#include "../mod_ScannerSet/ScannerSet_def_g.h"

using namespace ScannerSet;
using namespace AssistantChannel;
using namespace SelfChecker;
using namespace MediaController;


struct CCameraBrightValue
{
	int nValue;
	void Serialize(SpBuffer& Buf)
	{
		Buf& nValue;
	}
};


class CMediaControllerEntity;

class SelfChekerClient :public SelfCheckerService_ClientBase
{
public:
	SelfChekerClient(CMediaControllerEntity* pEntity);
};

class ChannelMediaControllerClient : public ChannelService_ClientBase
{
public:
	ChannelMediaControllerClient(CMediaControllerEntity* pEntity);
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_State_Info& Msg, CSmartPointer<IReleasable> pData);
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_Packet_Info& Msg, CSmartPointer<IReleasable> pData);
};

class MediaServiceSession : public MediaService_ServerSessionBase
{
public:
	MediaServiceSession(CMediaControllerEntity* pEntity) : m_pEntity(pEntity) {}
	virtual void Handle_GetVideoDeviceName(SpReqAnsContext<MediaService_GetVideoDeviceName_Req, MediaService_GetVideoDeviceName_Ans>::Pointer ctx);
	virtual void Handle_StartCamera(SpOnewayCallContext<MediaService_StartCamera_Info>::Pointer ctx);
	virtual void Handle_StopCamera(SpOnewayCallContext<MediaService_StopCamera_Info>::Pointer ctx);

	virtual void Handle_StartEnvCamera(SpReqAnsContext<MediaService_StartEnvCamera_Req, MediaService_StartEnvCamera_Ans>::Pointer ctx);
	virtual void Handle_StopEnvCamera(SpOnewayCallContext<MediaService_StopEnvCamera_Info>::Pointer ctx);
	//add by clp 20200319
	virtual void Handle_StartSpeakerRender(SpOnewayCallContext<MediaService_StartSpeakerRender_Info>::Pointer ctx);
	virtual void Handle_StopSpeakerRender(SpOnewayCallContext<MediaService_StopSpeakerRender_Info>::Pointer ctx);

private:
	CMediaControllerEntity* m_pEntity;
};


class CMediaControllerEntity : public CEntityBase, public ILogListener, public ITimerListener, public ISysVarListener
{
public:
	CMediaControllerEntity() : m_capture(NULL), m_salesaudio_capture(NULL), m_lCaptureEnvCount(0), m_nCameraErrorCode(Error_Succeed),
		m_lCaptureEnvOptCount(0), m_lCaptureOptCount(0), m_iEnvEmptyTimes(0), m_iOptEmptyTimes(0), m_bSendCameraError(false),
		m_nEnvCameraRestartNum(0), m_nOptCameraRestartNum(0), m_nCameraCount(2), m_pSelfcheckClient(NULL),
		strFrontCam("$"), strRearCam("$"), strEnvCam("$"), strUSBCam("$"), strEwsCam("$"), m_bCustomerwareBegin(false),
		m_pAudioRenderObj(NULL), m_bRecordPCM(false), m_bIsRemoteRecord(false), m_bHasStartSpeakerRender(false), m_bConnectedAssist(FALSE){

#ifdef RVC_OS_LINUX
		m_env_mutex = PTHREAD_MUTEX_INITIALIZER;
		m_opt_mutex = PTHREAD_MUTEX_INITIALIZER;
		m_envopt_mutex = PTHREAD_MUTEX_INITIALIZER;
		m_pAudioCap = NULL;
#endif
	}

	virtual ~CMediaControllerEntity() {}
	virtual const char* GetEntityName() const { return "MediaController"; }
	virtual bool IsService()const { return true; }
	virtual void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName);
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext);
	virtual void OnStarted();
	DeviceTypeEnum RvcGetDeviceType();
	void SetCameraSysVar(int n);
	ErrorCodeEnum GetSalesRecordAudioParam();
	ErrorCodeEnum SetEnvCameraOnSysVar(const CSimpleStringA strOnState);
	ErrorCodeEnum SetCameraSysVar(const CSimpleStringA& newVal);
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext);
	virtual void OnTimeout(DWORD dwTimerID);
	bool SetAutoBright(ErrorCodeEnum nCode);
	//camera gain adjust
	void OnReceivePkt(int sub_type, const char* buffer, int size);
	ErrorCodeEnum RealSelfCheck();
	void SendCameraBright();
	ErrorCodeEnum StartEnvCamera();
	ErrorCodeEnum StopEnvCamera();
	ErrorCodeEnum ExternStartCamera();
	ErrorCodeEnum ExternStopCamera();
	ErrorCodeEnum SaveInnerCamera();
	ErrorCodeEnum GetHSPCameras(CAutoArray<CSimpleStringA>& HSPCameras);
	ErrorCodeEnum HandleSalesRecordPCMAudio(bool bRemoteRecord, const char* pszMessage, audio_frame* pFrame = NULL);
	void HandleRemoteRecord(const char* pszMessage);
	ErrorCodeEnum StartSpeakerAudioRender(int iQueue, audio_frame* pFrame, const char* strName);
	ErrorCodeEnum StopSpeakerAudioRender();
	ErrorCodeEnum SetSalesRecordAudioCaptureTransActionData(eRvcPCMTransType eType, void* pData);


public:
	bool m_bSendCameraError;
	int m_iEnvEmptyTimes;
	int m_iOptEmptyTimes;
	int m_nEnvCameraRestartNum;
	int m_nOptCameraRestartNum;
	DeviceTypeEnum m_eDeviceType;
	BOOL m_bStartCamera;
	BOOL m_bExternControlCam;
	capture_config_t conf;
	rvc_audio_capture_config_s m_sales_audio_conf;			//销售双录音频配置
	ErrorCodeEnum m_nCameraErrorCode;     //摄像头故障码，0：无故障，1：env摄像头故障，2：opt摄像头故障，3：双摄像头故障
	int m_nCurActiveCamera;				//当前正在使用的摄像头
	CSimpleStringA strFrontCam;
	CSimpleStringA strRearCam;
	CSimpleStringA strEnvCam;           //Env摄像头 add by ly 20160331
	CSimpleStringA strUSBCam;           //外接摄像头 add by ly 20160329
	CSimpleStringA strEwsCam;			//外部广角摄像头路径名（全程录像用，通常不配置）
	int m_nCameraCount;                 //当前摄像头数量 add by ly 20160531
	int m_nSysCallType;					//0:普通模式，1：p2p模式
	capture_t* m_capture;
	rvc_sales_audio_capture_t* m_salesaudio_capture;
	BOOL m_bCustomerwareBegin;
	bool m_bHasStartSpeakerRender;			//add by clp 20200416	是否已开启扬声器音频采集


private:
	ErrorCodeEnum LoadRunConfig(CSimpleStringA& frontcam, CSimpleStringA& rearcam);
	ErrorCodeEnum CheckConfigCameraName(capture_config_t* conf);
	ErrorCodeEnum GetSalesAudioConfig(rvc_audio_capture_config_t* conf, bool bRemoteRecord);
	ErrorCodeEnum AutoGetVideoDeviceName(capture_config_t* conf);
	ErrorCodeEnum LoadConfig(capture_config_t* conf);
	void OnExternalCameraSwitchFailed(const char* pszFailedMsg);
	virtual void OnLog(const CAutoArray<CUUID>& SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
		const CAutoArray<DWORD>& Param, const char* pszEntityName, const char* pszModuleName, const char* pszMessage, const linkContext& pLinkInfo);
	virtual void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext);
	//获取当前使用摄像头，30分钟轮休一次
	int GetActiveCamera();
	ErrorCodeEnum ChangeSysvar(ErrorCodeEnum op);
	void AutoCorrectCameraConfigName(long wait_time);
	//开始销售双录音频采集函数
	ErrorCodeEnum StartSalesRecordAudioCapture(bool bRemoteRecord = false, eRvcPCMTransType eType = eUnKnown, void* pData = NULL);
	//停止销售双录音频采集函数
	ErrorCodeEnum StopSalesRecordAudioCapture();
	ErrorCodeEnum StartCamera();
	ErrorCodeEnum StartCamera(int nCamera);
	void StartCameraAndTiggerRecord(const char* strSessionId);
	ErrorCodeEnum ReStartCamera(int nCamera);
	virtual CServerSessionBase* OnNewSession(const char* pszRemoteEntityName, const char* pszClass);
	ErrorCodeEnum RvcGetAudioDevice();
	ErrorCodeEnum ConnectAssistChannel();
	void OnTimeCameraStatusCheck();

private:
	LONG m_lCaptureEnvCount;
	LONG m_lCaptureOptCount;
	LONG m_lCaptureEnvOptCount;
	CAutoArray<CUUID> m_arrListener;
	ChannelMediaControllerClient* m_pMediaControllerChannel;
	SelfChekerClient* m_pSelfcheckClient;
	IAudioRender* m_pAudioRenderObj;		
	bool m_bRecordPCM;						
	int m_nSalesAudioSmpPsec;				
	bool m_bIsRemoteRecord;					
	BOOL m_bConnectedAssist;

#ifdef RVC_OS_WIN
#else
	pthread_mutex_t m_env_mutex;
	pthread_mutex_t m_opt_mutex;
	pthread_mutex_t m_envopt_mutex;
	IAudioMgr* m_pAudioCap;
#endif
};