myvtm/Module/mod_localmediaplay/mod_localmediaplay.h

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

#ifdef RVC_OS_WIN
#include <Shlwapi.h>
#include "libwmpplayer.h"
#include "libimgplayer.h"
#else
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <unistd.h>
#endif // RVC_OS_WIN

#include "libmediaplayer.h"
#include "libpictureplayer.h"
#include "libaudioqueue.h"

#include "LocalMediaPlay_server_g.h"
#include "AdvertManage/mediaManage.h"
#include <iostream>
#include <vector>

#include "modVer.h"
#include "EventCode.h"

using namespace LocalMediaPlay;

#define MAX_PLAY_CHANNELS					3						//最大播放通道数


#ifndef RVC_AUDIO_LEN
#define RVC_AUDIO_LEN 320
#endif // !RVC_AUDIO_LEN

#ifndef RVC_AUDIO_BUFFER_LEN
#define RVC_AUDIO_BUFFER_LEN 320*8*2
#endif // !RVC_AUDIO_BUFFER_LEN

typedef struct {
	int nCfgInx;
	int nWndX;
	int nWndY;
	int nWndWidth;
	int nWndHeight;
}MediaPlayParam;

#ifdef RVC_OS_WIN
	DWORD WINAPI qryMedia(LPVOID lpv);
	DWORD WINAPI MediaPlayThread(LPVOID param);
	DWORD WINAPI NoticePlayThread(LPVOID param);
	DWORD WINAPI StartMediaPlayFunc(LPVOID param);
	DWORD WINAPI StartAudioPlayingThreadFunc(LPVOID param);
	DWORD WINAPI StartNoticePlayThreadFunc(LPVOID param);
#endif


#ifdef RVC_OS_WIN
class CLocalMediaPlayEntity : public CWmpHostApi, public CImgHostApi, public CMediaHostApi, public CPicHostApi, public CEntityBase, public ILogListener
#else
class CLocalMediaPlayEntity : public CMediaHostApi, public CPicHostApi, public CEntityBase, public ILogListener
#endif // RVC_OS_WIN
{
public:
	CLocalMediaPlayEntity();
	virtual ~CLocalMediaPlayEntity();

	virtual const char *GetEntityName() const { return "LocalMediaPlay"; }

	virtual bool IsService() const { return true; }

	const char* GetEntityVersion() const override
	{
		return MODULE_VERSION_FULL;
	}

	virtual CServerSessionBase *OnNewSession(const char* pszRemoteEntityName, const char * pszClass);

	virtual DeviceTypeEnum RvcGetDeviceType();
	
#ifdef RVC_OS_WIN
	virtual bool LoadPlayConfig(CWmpPlayConfig& config, int CfgInx);

	virtual bool LoadPlayConfig(CImgPlayConfig& config, int CfgInx);

	virtual void WmpDebug(const char* fmt, ...);

	virtual void WmpLogEvt(int ievent, const char* strmsg);

	virtual void ImgDebug(const char* fmt, ...);
#endif // _WIN32
	virtual int LoadPlayConfig(CMediaPlayConfig& config, int CfgInx);

	virtual int LoadPlayConfig(CPicPlayConfig& config, int CfgInx);

	virtual void Debug(media_loglevel log_level, const char* fmt, ...);

	virtual void PicDebug(pic_loglevel log_level, const char* fmt, ...);

	virtual void MediaPlayFinished(int iMediaType);

	virtual int GetMediaPlayerIcoPath(char* strPath, int uLen);

	virtual int GetPicPlayerIcoPath(char* strPath, int uLen);

	virtual int GetAudioOutDevName(char* strDev, int uLen);

	virtual int PlayingAudioDataCallback(audio_param_t* param, const void* input, unsigned long uaudiolen);

	bool GetPlayFlag();

	bool GetScanExitFlag();

	ErrorCodeEnum HandleRemoteRecord(const char* pszMessage);	

	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 OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext);

	ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError);

	virtual void OnStarted();

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext);

	ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError);

	void StartVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight);

	void StartAudio(const char *pAudioNames);

	void StartImage(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight);

	void StopVideo(int nCfgInx);

	void StopAudio();

	void StopImage(int nCfgInx);

	void StopAll();

	bool GetLocalVideoVolume(int nCfgInx, int &nVolume);

	bool SetLocalVideoVolume(int nCfgInx, int nVolume);

	std::pair<bool, int> GetLocalAudioVolume();

	bool SetLocalAudioVolume(int nVolume);

	bool IsRunConfigExist();

	ErrorCodeEnum StartNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName);

	ErrorCodeEnum StartMediaPlayerNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName);

	ErrorCodeEnum StartFFPlayerNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName);

	ErrorCodeEnum LoadEntityConfig();
	
	ErrorCodeEnum StopNotice(int nCfgInx);

	ErrorCodeEnum StopPlayAllMedias();
	
	DeviceTypeEnum GetDeviceType();

private:

	virtual void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext);

#ifdef RVC_OS_WIN

	friend DWORD WINAPI qryMedia(LPVOID lpv);

	friend DWORD WINAPI MediaPlayThread(LPVOID param);

	friend DWORD WINAPI NoticePlayThread(LPVOID param);

	friend DWORD WINAPI StartMediaPlayFunc(LPVOID param);

	friend DWORD WINAPI StartAudioPlayingThreadFunc(LPVOID param);

	friend DWORD WINAPI StartNoticePlayThreadFunc(LPVOID param);
#else
	friend void* queryMedia(void* param);
	
	friend void* StartAudioPlayingThreadFunc(void* param);
	
	friend void* StartMediaPlayFunc(void* param);
	
	friend void* StartNoticePlayThreadFunc(void* param);

#endif // RVC_OS_WIN

	void setMediaPath();

	void loadDefaultMedia(bool fNewVersion = true);

	int GetPlayerIcoPath(char* strPath, int iLen);

	int GetAudioOutDev();

	void LogLocalMediaPlayVolumeInfo();

private:
	int m_id_seq;
	
	CUUID m_SubIDIEIdle;
	
	CUUID m_SubIDStartRecord;
	
	CUUID m_SubIDStopRecord;

#ifdef RVC_OS_WIN
	// 视频播放对象指针数组
	Clibwmpplayer* m_pVideoPlayer[MAX_PLAY_CHANNELS];
	// 音频播放对象指针
	Clibwmpplayer* m_pAudioPlayer;
	// 图片播放对象指针数组
	Clibimgplayer* m_pImagePlayer[MAX_PLAY_CHANNELS];
#endif // RVC_OS_WIN
	// 媒体播放对象指针数组
	Clibmediaplayer* m_pMediaPlayer[MAX_PLAY_CHANNELS];
	// 图片播放对象指针数组
	Clibpictureplayer* m_pPicturePlayer[MAX_PLAY_CHANNELS];
	
	Clibmediaplayer* m_pMediaAudioPlayer;

	mediaManage m_mediaManage;
	MediaPlayParam m_mediaParam;
	int m_defaultVolum;
	std::string m_lastPlayAudio;
	std::string m_lastPlayVideo;
	DeviceTypeEnum m_eDeviceType;
	CSimpleStringA m_AudioPath;
	CSimpleStringA m_VideoPath;
	bool m_bLocalPicLogFlag;
	bool m_bRecordPCM;
	bool m_bStartRecord;
	bool m_bloged;

	
#ifdef RVC_OS_WIN
	HANDLE m_hStopMediaPlayEvent;
	HANDLE m_scanThreadId;
	HANDLE m_uMediaPlayThreadId;
	HANDLE m_uAudioPlayThreadId;
	HANDLE m_uNoticePlayThreadId;
	HANDLE m_scanThread, m_playThread;
	vector<CWmpPlayConfig> m_defaultVideo;
	vector<CWmpPlayConfig> m_defaultAudio;
	vector<CImgPlayConfig> m_defaultImg;
#else
	pthread_t m_scanThreadId;
	pthread_t m_uAudioPlayThreadId;
	sem_t m_stop_mediaplay_semt;
	pthread_t m_uMediaPlayThreadId;
	pthread_t m_uNoticePlayThreadId;
#endif // RVC_OS_WIN

	vector<CMediaPlayConfig> m_Videos;
	vector<CMediaPlayConfig> m_Audios;
	vector<CPicPlayConfig> m_defaultPic;

	volatile bool m_badplayflag;
	bool m_scanexitflag;
	CSimpleStringA m_strAudioOutDev;
	bool m_bgetflag;
	bool m_bgetico;
	Clibaudioqueue* m_remote_audio_queue;
	FILE* m_pFile;
	char m_audiobuffer[RVC_AUDIO_BUFFER_LEN];
	int m_leftlen;
	int m_iseriesnumber;
	bool m_buserstopaudio;
	int m_iPlayType;
	pic_loglevel m_piclevel;
	media_loglevel m_medialevel;
};


class CLocalMediaPlaySession : public PlayService_ServerSessionBase
{
public:
	CLocalMediaPlaySession(CLocalMediaPlayEntity* pEntity, int id) : m_id(id), m_pEntity(pEntity)
	{
	}

	virtual void Handle_StartPlayVideo(SpReqAnsContext<PlayService_StartPlayVideo_Req, PlayService_StartPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StartPlayAudio(SpReqAnsContext<PlayService_StartPlayAudio_Req, PlayService_StartPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StartPlayImage(SpReqAnsContext<PlayService_StartPlayImage_Req, PlayService_StartPlayImage_Ans>::Pointer ctx);

	virtual void Handle_StopPlayVideo(SpReqAnsContext<PlayService_StopPlayVideo_Req, PlayService_StopPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StopPlayAudio(SpReqAnsContext<PlayService_StopPlayAudio_Req, PlayService_StopPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StopPlayImage(SpReqAnsContext<PlayService_StopPlayImage_Req, PlayService_StopPlayImage_Ans>::Pointer ctx);

	virtual void OnClose(ErrorCodeEnum eErrorCode);

	virtual void Handle_GetLocalVideoVolume(SpReqAnsContext<PlayService_GetLocalVideoVolume_Req, PlayService_GetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalVideoVolume(SpReqAnsContext<PlayService_SetLocalVideoVolume_Req, PlayService_SetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_GetLocalAudioVolume(SpReqAnsContext<PlayService_GetLocalAudioVolume_Req, PlayService_GetLocalAudioVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalAudioVolume(SpReqAnsContext<PlayService_SetLocalAudioVolume_Req, PlayService_SetLocalAudioVolume_Ans>::Pointer ctx);

	virtual void Handle_StartPlayNotice(SpReqAnsContext<PlayService_StartPlayNotice_Req, PlayService_StartPlayNotice_Ans>::Pointer ctx);

	virtual void Handle_StopPlayNotice(SpReqAnsContext<PlayService_StopPlayNotice_Req, PlayService_StopPlayNotice_Ans>::Pointer ctx);

	virtual void Handle_StopPlayAllMedias(SpReqAnsContext<PlayService_StopPlayAllMedias_Req, PlayService_StopPlayAllMedias_Ans>::Pointer ctx);

private:
	int m_id;
	CLocalMediaPlayEntity* m_pEntity;
};