myvtm/Module/mod_localmediaplay/mod_localmediaplay.cpp

#include "stdafx.h"
#include "mod_localmediaplay.h"
#include "LocalMediaPlay_msg_g.h"
#include "y2k_time.h"
#include "fileutil.h"

#include "rvc_media_common.h"
#include <stdint.h>
#include "../mod_interactivecontrol/Event.h"
#include "Event.h"

#ifndef RVC_MIN_LOCALPLAYER_TIME
#define RVC_MIN_LOCALPLAYER_TIME 1
#endif


#define DEFAULT_SLEEP_TIME		1000
#define DEFAULT_ADVERT_TYPE		'A'

bool IS_DEBUG = false;
int scanTime = 600;
int removeOldTime = 1800;

#ifndef MAX_LOCAL_MEDIAS
#define MAX_LOCAL_MEDIAS 128
#endif // !MAX_LOCAL_MEDIAS


#ifndef RVC_MIN_LOCALPLAYER_TIME
#define RVC_MIN_LOCALPLAYER_TIME 6
#endif

#ifndef RVC_VIDEOPLAY_START_TIME
#define RVC_VIDEOPLAY_START_TIME "09:00:00"
#endif // !RVC_VIDEOPLAY_START_TIME


#ifndef RVC_VIDEOPLAY_END_TIME
#define RVC_VIDEOPLAY_END_TIME "17:30:00"
#endif // !RVC_VIDEOPLAY_END_TIME


#ifndef rvc_snprintf
#ifdef RVC_OS_WIN
#define rvc_snprintf _snprintf
#else
#define rvc_snprintf snprintf
#endif // RVC_OS_WIN

#endif // rvc_snprintf


static uint32_t ConvertStereo2Mono(char* pDstBuf, const uint32_t uDstLen, char* pSrcBuf, uint32_t uSrcLen, uint32_t uBitDeepth)
{
	uint32_t uRet = 0;
	uint32_t uOneChannelLen = uSrcLen / 2;
	uint32_t i = 0;

	for (; i < uOneChannelLen / 2 && i < uDstLen / uBitDeepth; i++) {
		memcpy((uint16_t*)pDstBuf + i, ((uint32_t*)(pSrcBuf)) + i, uBitDeepth);
	}

	if (i == uOneChannelLen / 2) {
		uRet = uOneChannelLen;
	}

	return uRet;
}


static uint32_t Transform2Pcm8k(char* pdstbuf, const uint32_t udstlen, char* pcm_441kdata, int idata_size, int ichannels)
{
	uint32_t nLen = 0;
	int nSkipByte = 5 * ichannels;
	int nSourcePos = 0;
	char* pcm_8k_data = (char*)pdstbuf;
	for (nLen = 0; nSourcePos + 1 < idata_size; nLen = nLen + 2)
	{
		pcm_8k_data[nLen] = pcm_441kdata[nSourcePos];
		pcm_8k_data[nLen + 1] = pcm_441kdata[nSourcePos + 1];

		if (nSkipByte == 5 * ichannels) {
			nSkipByte = 6 * ichannels;
		}
		else {
			nSkipByte = 5 * ichannels;
		}
		nSourcePos = nSourcePos + nSkipByte * 2;
	}

	return nLen;
}


static uint32_t PcmConvert(char* pdstbuf, const uint32_t udstlen, char* pcmsrcdata, int isrclen, int isamplespersec, int ichannels)
{
	uint32_t uLen = 0;
	if (2 == ichannels) {
		if (8000 == isamplespersec) {
			uLen = ConvertStereo2Mono(pdstbuf, udstlen, pcmsrcdata, isrclen, 2);
		}
		else if (44100 == isamplespersec) {
			uLen = Transform2Pcm8k(pdstbuf, udstlen, pcmsrcdata, isrclen, 2);
		}
	}
	else {
		if (44100 == isamplespersec) {
			uLen = Transform2Pcm8k(pdstbuf, udstlen, pcmsrcdata, isrclen, 1);
		}
	}

	return uLen;
}


static void CStringSplit(char* str, char** result, const char* del)
{
	char* pdata = NULL;
	char* p = NULL;

#ifdef RVC_OS_WIN
	p = strtok_s(str, del, &pdata);
#else
	p = strtok_r(str, del, &pdata);
#endif // RVC_OS_WIN

	while (p != NULL) {
		*result++ = p;
#ifdef RVC_OS_WIN
		p = strtok_s(NULL, del, &pdata);
#else
		p = strtok_r(NULL, del, &pdata);
#endif
	}
}


static bool IsValidPlayTime(const char* pstrStartTime, const char* pstrEndTime)
{
	bool bRet = true;
	if (NULL == pstrStartTime || NULL == pstrEndTime) {
		return false;
	}

#ifdef DEVOPS_ON_ST

#else
#ifdef RVC_OS_WIN
	SYSTEMTIME st;
	GetLocalTime(&st);
	char strNow[MAX_PATH] = { 0 };
	_snprintf(strNow, MAX_PATH, "%02d:%02d:%02d", st.wHour, st.wMinute, st.wSecond);
	if (strcmp(strNow, pstrStartTime) < 0 || strcmp(strNow, pstrEndTime) >= 0) {
		bRet = false;
	}
#else
	struct tm* ptm = NULL;
	time_t t = time(NULL);
	ptm = localtime(&t);
	char strNow[TIME_LEN] = { 0 };
	sprintf(strNow, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
	if (strcmp(strNow, pstrStartTime) < 0 || strcmp(strNow, pstrEndTime) >= 0) {
		bRet = false;
	}
#endif // RVC_OS_WIN

#endif

	return bRet;
}

#ifdef RVC_OS_WIN
DWORD WINAPI clearOutdata(LPVOID lpv)
{
	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)lpv;
	Sleep(removeOldTime * 1000);
	curEntity->m_mediaManage.clearOutdataResource();
	return 0;
}

DWORD WINAPI qryMedia(LPVOID lpv)
{
	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)lpv;
	Sleep(3000);

	while (true){
		curEntity->m_mediaManage.InitResourceListByLocal();
		Sleep(3600 * 1000);
	}

	return 0;
}

#else
void* queryMedia(void* param)
{
	CLocalMediaPlayEntity* curEntity = (CLocalMediaPlayEntity*)param;
	sleep(3);

	while (false == curEntity->GetScanExitFlag())
	{
		curEntity->m_mediaManage.InitResourceListByLocal();
		sleep(3600);
	}

	return 0;
}

void sig_handler(int signum)
{
	if (SIGTERM == signum){
		int ipid = getpid();
		kill(ipid, SIGKILL);
	}
}

#endif // RVC_OS_WIN


CLocalMediaPlayEntity::CLocalMediaPlayEntity() : m_id_seq(0), m_connection(NULL)
{
	m_defaultVolum = 50;
#ifdef RVC_OS_WIN
	m_pAudioPlayer = NULL;
	m_scanThread = NULL;
	m_playThread = NULL;
	memset(m_pVideoPlayer, 0, sizeof(m_pVideoPlayer));
	memset(m_pImagePlayer, 0, sizeof(m_pImagePlayer));
#endif // RVC_OS_WIN

	ZeroMemory(&m_mediaParam, sizeof(MediaPlayParam));
	m_pMediaAudioPlayer = NULL;
	memset(m_pMediaPlayer, 0, sizeof(m_pMediaPlayer));
	memset(m_pPicturePlayer, 0, sizeof(m_pPicturePlayer));

#ifdef RVC_OS_WIN
	m_scanThreadId = NULL;
	m_uMediaPlayThreadId = NULL;
	m_uNoticePlayThreadId = NULL;
#else
	m_scanThreadId = 0;
	m_uMediaPlayThreadId = 0;
	m_uNoticePlayThreadId = 0;
#endif // !RVC_OS_WIN
	m_scanexitflag = false;
	m_badplayflag = true;
	m_bgetflag = false;
	m_bgetico = false;
	m_remote_audio_queue = NULL;
	m_pFile = NULL;
	m_bRecordPCM = false;
	m_iPlayType = 0;
	m_bStartRecord = false;
	m_leftlen = 0;
	m_piclevel = PIC_LOG_INFO;
	m_medialevel = MEDIA_LOG_INFO;
}


CLocalMediaPlayEntity::~CLocalMediaPlayEntity()
{
	SecureClientRelease();

#ifdef RVC_OS_WIN
	DWORD exitCode = 0;
	if (m_scanThread){
		TerminateThread(m_scanThread, exitCode);
		m_scanThread = NULL;
	}
#else
	m_scanexitflag = true;
	if (0 == pthread_join(m_scanThreadId, NULL)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pthread join scanThreadId success.");
	}
	m_bgetflag = false;
	m_bgetico = false;
	
#endif // RVC_OS_WIN
}

void CLocalMediaPlayEntity::SecureClientRelease()
{
	if (NULL != m_connection){
		if (m_connection->IsConnectionOK()) {
			m_connection->Close();
		}
			
		m_connection->DecRefCount();
		m_connection = NULL;
	}
}

bool CLocalMediaPlayEntity::SecureClientConnect()
{
	if (NULL != m_connection && m_connection->IsConnectionOK()) {
		return true;
	}
	SecureClientRelease();
	m_connection = new CAdvertSyncConnection(this);

	return m_connection->ConnectFromCentralSetting();
}

void CLocalMediaPlayEntity::setMediaPath()
{
	CSimpleStringA downloadPath, mediaPath;
	GetFunction()->GetPath("Download", downloadPath);
	GetFunction()->GetPath("Ad", mediaPath);
	mediaPath += SPLIT_SLASH_STR;
	mediaPath += "Video";
	m_mediaManage.setDefaultDownloadPath(downloadPath.GetData());
	m_mediaManage.setDefaultAddvertPath(mediaPath.GetData());
}

CServerSessionBase* CLocalMediaPlayEntity::OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
{
	return new CLocalMediaPlaySession(this, m_id_seq++);
}


#ifdef RVC_OS_WIN
bool CLocalMediaPlayEntity::LoadPlayConfig(CWmpPlayConfig &config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return false;
	}

	if (config.eMode == LOCALAUDIO && CfgInx < m_defaultAudio.size()) {
		memcpy(&config, &(m_defaultAudio[CfgInx]), sizeof(CWmpPlayConfig));
	}
	else if (config.eMode == LOCALVIDEO && CfgInx < m_defaultVideo.size()) {
		memcpy(&config, &(m_defaultVideo[CfgInx]), sizeof(CWmpPlayConfig));
	}
	else {
		return false;
	}
		
	return true;
}

bool CLocalMediaPlayEntity::LoadPlayConfig(CImgPlayConfig &config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return false;
	}

	memcpy(&config, &(m_defaultImg[CfgInx]), sizeof(CImgPlayConfig));

	return true;
}


void CLocalMediaPlayEntity::WmpDebug(const char *fmt, ...)
{
	va_list arg;
	va_start(arg, fmt);

	int n = _vsnprintf(NULL, 0, fmt, arg);
	if (n >= 512) {
		char* buf = (char*)malloc((size_t)(n + 1));
		_vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else{
		char strlog[512] = {0};
		_vsnprintf(strlog, 512, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
	}
	va_end(arg);
}

void CLocalMediaPlayEntity::WmpLogEvt(int ievent, const char* strmsg)
{
	if (0 == ievent){
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_VICE_MONITOR_NOT_EXIST, strmsg);
	}
	else if(1 == ievent){
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_VICE_MONITOR_SET_ERROR, strmsg);
	}
}

void CLocalMediaPlayEntity::ImgDebug(const char *fmt, ...)
{
	va_list arg;
	va_start(arg, fmt);

	int n = _vsnprintf(NULL, 0, fmt, arg);
	if (n >= 512) {
		char* buf = (char*)malloc((size_t)(n + 1));
		_vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else{
		char strlog[512] = {0};
		_vsnprintf(strlog, 512, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
	}
	va_end(arg);
}

#endif // RVC_OS_WIN

void CLocalMediaPlayEntity::loadDefaultMedia(bool fNewVersion)
{
	if (!fNewVersion) {
#ifdef RVC_OS_WIN
		m_defaultImg.clear();
		m_defaultAudio.clear();
		m_defaultVideo.clear();
#endif // RVC_OS_WIN
	}
	else {
		m_defaultPic.clear();
		m_Audios.clear();
		m_Videos.clear();
	}

	// 获取本地媒体根目录
	CSimpleStringA strRootPath("");
	ErrorCodeEnum Error = Error_Succeed;
	Error = GetFunction()->GetPath("ADData", strRootPath);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Fail to get local media root path!");
		return;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("local media root path is %s.", strRootPath.GetData());

	CSmartPointer<IConfigInfo> spConfigCen;
	if (Error_Succeed == GetFunction()->OpenConfig(Config_CenterSetting, spConfigCen)) {
		IS_DEBUG = false;
		do {
			int value(0);
			spConfigCen->ReadConfigValueInt(GetEntityName(), "runDebug", value);
			if (value > 0) {
				IS_DEBUG = true;
			}
		} while (false);

		scanTime = 600;
		removeOldTime = 1800;
		do {
			int value(0);
			spConfigCen->ReadConfigValueInt(GetEntityName(), "scanTime", value);
			if (value > 0) {
				scanTime = value;
			}
		} while (false);

		do {
			int value(0);
			spConfigCen->ReadConfigValueInt(GetEntityName(), "removeOldTime", value);
			if (value > 0) {
				removeOldTime = value;
			}
		} while (false);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("runDebug:%s, scanTime:%d", IS_DEBUG ? "true" : "false", scanTime);
	}

	CSimpleStringA imgPath = strRootPath + SPLIT_SLASH_STR + "Image" + SPLIT_SLASH_STR;
	//Image0
	do {
		if (!fNewVersion) {
#ifdef RVC_OS_WIN
			CImgPlayConfig curImg;
			ZeroMemory(&curImg, sizeof(CImgPlayConfig));
			strncpy(curImg.strRootPath, imgPath.GetData(), sizeof(curImg.strRootPath));
			curImg.bFullScreen = true;
			curImg.bPrimMonitor = false;
			curImg.nPlayCnt = 0;
			curImg.nPlayInterval = 5000;

			curImg.nFileCnt = 4;
			for (int i = 0; i < curImg.nFileCnt; ++i) {
				rvc_snprintf(curImg.strFileNames[i], MAX_PATH, "Ad0%s%d.jpg", SPLIT_SLASH_STR, i);
			}
			m_defaultImg.push_back(curImg);
#endif
		}
		else {
			CPicPlayConfig curImg1;
			ZeroMemory(&curImg1, sizeof(CPicPlayConfig));
			strncpy(curImg1.strRootPath, imgPath.GetData(), sizeof(curImg1.strRootPath));

			curImg1.bFullScreen = true;
			curImg1.bPrimMonitor = false;
			curImg1.nPlayCnt = 0;
			curImg1.nPlayInterval = 5000;
			curImg1.nFileCnt = 4;
			for (int i = 0; i < curImg1.nFileCnt; ++i) {
				rvc_snprintf(curImg1.strFileNames[i], MAX_PATH, "Ad0%s%d.jpg", SPLIT_SLASH_STR, i);
			}
			m_defaultPic.push_back(curImg1);
		}
	} while (false);
	//Image1
	do {
		if (!fNewVersion) {
#ifdef RVC_OS_WIN
			CImgPlayConfig curImg;
			ZeroMemory(&curImg, sizeof(CImgPlayConfig));
			strncpy(curImg.strRootPath, imgPath.GetData(), sizeof(curImg.strRootPath));

			curImg.bFullScreen = false;
			curImg.bPrimMonitor = true;
			curImg.nPlayCnt = 6;
			curImg.nPlayInterval = 1000;
			curImg.nFileCnt = 4;

			for (int i = 0; i < curImg.nFileCnt; ++i) {
				rvc_snprintf(curImg.strFileNames[i], MAX_PATH, "Ad1%s%d.jpg", SPLIT_SLASH_STR, i);
			}
			m_defaultImg.push_back(curImg);
#endif
		}
		else {
			CPicPlayConfig curImg1;
			ZeroMemory(&curImg1, sizeof(CPicPlayConfig));
			strncpy(curImg1.strRootPath, imgPath.GetData(), sizeof(curImg1.strRootPath));

			curImg1.bFullScreen = true;
			curImg1.bPrimMonitor = false;
			curImg1.nPlayCnt = 6;
			curImg1.nPlayInterval = 1000;
			curImg1.nFileCnt = 4;
			for (int i = 0; i < curImg1.nFileCnt; ++i) {
				rvc_snprintf(curImg1.strFileNames[i], MAX_PATH, "Ad1%s%d.jpg", SPLIT_SLASH_STR, i);
			}
			m_defaultPic.push_back(curImg1);
		}
	} while (false);

	CSimpleStringA videoPath = strRootPath + SPLIT_SLASH_STR + "Video" + SPLIT_SLASH_STR;
	//Video0
	do {
		if (!fNewVersion) {
#ifdef RVC_OS_WIN
			CWmpPlayConfig curVideo;
			ZeroMemory(&curVideo, sizeof(CWmpPlayConfig));
			strcpy(curVideo.strRootPath, videoPath.GetData());
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curVideo.strRootPath);

			curVideo.bFullScreen = true;
			curVideo.bPrimMonitor = false;
			curVideo.bSimpleMode = true;
			curVideo.nPlayCnt = 1;
			curVideo.nPlayInterval = 2000;
			curVideo.nVolume = 50;
			CSmartPointer<IConfigInfo> tempConfig;
			Error = GetFunction()->OpenConfig(Config_Run, tempConfig);
			if (Error == Error_Succeed) {
				Error = tempConfig->ReadConfigValueInt("LocalVideo", "Volume", curVideo.nVolume);
				if (Error != Error_Succeed || curVideo.nVolume < 0 || curVideo.nVolume > 100)
					curVideo.nVolume = 50;
				m_defaultVolum = curVideo.nVolume;
			}
			strcpy(curVideo.strVideoRunTime_S, RVC_VIDEOPLAY_START_TIME);
			strcpy(curVideo.strVideoRunTime_E, RVC_VIDEOPLAY_END_TIME);

			curVideo.nFileCnt = 1;
			strcpy(curVideo.strFileNames[0], "可视柜台欢迎界面.wmv");
			m_defaultVideo.push_back(curVideo);
#endif // RVC_OS_WIN
		}
		else {
			CMediaPlayConfig curVideo1 = { 0 };
			strcpy(curVideo1.strRootPath, videoPath.GetData());

			curVideo1.bFullScreen = true;
			curVideo1.bPrimMonitor = false;
			curVideo1.bSimpleMode = true;
			curVideo1.nPlayCnt = 1;
			curVideo1.nPlayInterval = 2000;
			curVideo1.nVolume = 50;
			curVideo1.nFileCnt = 1;

			strcpy(curVideo1.strFileNames[0], "可视柜台欢迎界面.wmv");
			
			strcpy(curVideo1.strVideoRunTime_S, RVC_VIDEOPLAY_START_TIME);
			strcpy(curVideo1.strVideoRunTime_E, RVC_VIDEOPLAY_END_TIME);

			m_Videos.push_back(curVideo1);
		}

	} while (false);
	//Video1
	do {
		if (!fNewVersion) {
#ifdef RVC_OS_WIN
			CWmpPlayConfig curVideo;
			ZeroMemory(&curVideo, sizeof(CWmpPlayConfig));
			strcpy(curVideo.strRootPath, videoPath.GetData());
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curVideo.strRootPath);

			curVideo.bFullScreen = true;
			curVideo.bPrimMonitor = false;
			curVideo.bSimpleMode = true;
			curVideo.nPlayCnt = 0;
			curVideo.nPlayInterval = 10000;
			curVideo.nVolume = 50;
			CSmartPointer<IConfigInfo> tempConfig;
			Error = GetFunction()->OpenConfig(Config_Run, tempConfig);
			if (Error == Error_Succeed) {
				Error = tempConfig->ReadConfigValueInt("LocalVideo", "Volume", curVideo.nVolume);
				if (Error != Error_Succeed || curVideo.nVolume < 0 || curVideo.nVolume > 100)
					curVideo.nVolume = 50;
				m_defaultVolum = curVideo.nVolume;
			}
			strcpy(curVideo.strVideoRunTime_S, RVC_VIDEOPLAY_START_TIME);
			strcpy(curVideo.strVideoRunTime_E, RVC_VIDEOPLAY_END_TIME);

			curVideo.nFileCnt = 1;
			strcpy(curVideo.strFileNames[0], "存款保险标识0418.wmv");
			m_defaultVideo.push_back(curVideo);
#endif // RVC_OS_WIN
		}
		else {
			CMediaPlayConfig curVideo1 = { 0 };
			strcpy(curVideo1.strRootPath, videoPath.GetData());

			curVideo1.bFullScreen = true;
			curVideo1.bPrimMonitor = false;
			curVideo1.bSimpleMode = true;
			curVideo1.nPlayCnt = 0;
			curVideo1.nPlayInterval = 10000;
			curVideo1.nVolume = 50;
			curVideo1.nFileCnt = 1;
			strcpy(curVideo1.strFileNames[0], "存款保险标识0418.wmv");
			
			strcpy(curVideo1.strVideoRunTime_S, RVC_VIDEOPLAY_START_TIME);
			strcpy(curVideo1.strVideoRunTime_E, RVC_VIDEOPLAY_END_TIME);

			m_Videos.push_back(curVideo1);
		}
	} while (false);

	CSimpleStringA audioPath = strRootPath + SPLIT_SLASH_STR + "Audio" + SPLIT_SLASH_STR;
	m_AudioPath = audioPath;
	//Audio
	do {
		if (!fNewVersion) {
#ifdef RVC_OS_WIN
			CWmpPlayConfig curAudio;
			ZeroMemory(&curAudio, sizeof(CWmpPlayConfig));
			strcpy(curAudio.strRootPath, audioPath.GetData());
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("config.strRootPath: %s", curAudio.strRootPath);
			curAudio.nPlayCnt = 1;
			curAudio.nPlayInterval = 5000;
			auto audioRet = GetLocalAudioVolume();
			if (audioRet.first) {
				curAudio.nVolume = audioRet.second;
			}
			else {
				curAudio.nVolume = m_defaultVolum;
			}
			m_defaultAudio.push_back(curAudio);
#endif
		}
		else {
			CMediaPlayConfig curAudio1 = { 0 };
			strcpy(curAudio1.strRootPath, audioPath.GetData());
			curAudio1.nPlayCnt = 1;
			curAudio1.nPlayInterval = 5000;
			auto audioRet = GetLocalAudioVolume();
			if (audioRet.first) {
				curAudio1.nVolume = audioRet.second;
			}
			else {
				curAudio1.nVolume = m_defaultVolum;
			}
			m_Audios.push_back(curAudio1);
		}
	} while (false);

#ifdef RVC_OS_WIN
	for (vector<CWmpPlayConfig>::iterator i = m_defaultVideo.begin(); i != m_defaultVideo.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_defaultVideo %s.", i->strFileNames[index]);
			}
		}
	}

	for (vector<CWmpPlayConfig>::iterator i = m_defaultAudio.begin(); i != m_defaultAudio.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_defaultAudio %s.", i->strFileNames[index]);
			}
		}
	}
	
	for (vector<CImgPlayConfig>::iterator i = m_defaultImg.begin(); i != m_defaultImg.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_defaultImg %s.", i->strFileNames[index]);
			}
		}
	}
#endif

	for (vector<CMediaPlayConfig>::iterator i = m_Videos.begin(); i != m_Videos.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_Videos %s.", i->strFileNames[index]);
			}
		}
	}

	for (vector<CMediaPlayConfig>::iterator i = m_Audios.begin(); i != m_Audios.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_Audios %s.", i->strFileNames[index]);
			}
		}
	}

	for (vector<CPicPlayConfig>::iterator i = m_defaultPic.begin(); i != m_defaultPic.end(); i++) {
		for (int index = 0; index < MAX_FILECOUNT; index++) {
			if (strlen(i->strFileNames[index])) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_defaultPic %s.", i->strFileNames[index]);
			}
		}
	}
}


int CLocalMediaPlayEntity::LoadPlayConfig(CMediaPlayConfig& config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return -1;
	}

	if (config.eMode == MEDIA_LOCALAUDIO && CfgInx < m_Audios.size()){
		memcpy(&config, &(m_Audios[CfgInx]), sizeof(CMediaPlayConfig));
	}
	else if (config.eMode == MEDIA_LOCALVIDEO && CfgInx < m_Videos.size()){
		memcpy(&config, &(m_Videos[CfgInx]), sizeof(CMediaPlayConfig));
	}
	else {
		return -1;
	}

	return 0;
}


int CLocalMediaPlayEntity::LoadPlayConfig(CPicPlayConfig& config, int CfgInx)
{
	if (CfgInx >= MAX_PLAY_CHANNELS || CfgInx < 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while LoadConfig!");
		return -1;
	}

	memcpy(&config, &(m_defaultPic[CfgInx]), sizeof(CPicPlayConfig));

	return 0;
}


void CLocalMediaPlayEntity::Debug(media_loglevel log_level, const char* fmt, ...)
{
	if (log_level >= m_medialevel){
		va_list arg;
		va_start(arg, fmt);
		int n = vsnprintf(NULL, 0, fmt, arg);
		if (n >= MAX_PATH) {
			char* buf = (char*)malloc((size_t)(n + 1));
			vsnprintf(buf, n + 1, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
			free(buf);
		}
		else {
			char strlog[MAX_PATH] = { 0 };
			vsnprintf(strlog, MAX_PATH, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
		}
		va_end(arg);
	}
}


void CLocalMediaPlayEntity::PicDebug(pic_loglevel log_level, const char* fmt, ...)
{
	if (log_level >= m_piclevel){
		va_list arg;
		va_start(arg, fmt);
		int n = vsnprintf(NULL, 0, fmt, arg);
		if (n >= MAX_PATH) {
			char* buf = (char*)malloc((size_t)(n + 1));
			vsnprintf(buf, n + 1, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
			free(buf);
		}
		else {
			char strlog[MAX_PATH] = { 0 };
			vsnprintf(strlog, MAX_PATH, fmt, arg);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
		}
		va_end(arg);
	}
}

void CLocalMediaPlayEntity::MediaPlayFinished(int iMediaType)
{
	if (0 == iMediaType) {
		AudioPlayRet ret;
		ret.AudioNames = m_lastPlayAudio.c_str();
		ret.ret = true;
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play audio %s success.", ret.AudioNames.GetData());
		if (false == m_buserstopaudio) {
			SpSendBroadcast(GetFunction(), eMsg_AudioPlayRet, eMsgSig_AudioPlayRet, ret);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SpSendBroadcast AudioPlayRet and audio name is %s.", ret.AudioNames.GetData());
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("user stop, not broadcast!");
		}
	}
	else {
		VideoPlayRet ret;
		ret.VideoNames = m_lastPlayVideo.c_str();
		ret.ret = true;
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video notice %s success.", ret.VideoNames.GetData());
		SpSendBroadcast(GetFunction(), eMsg_VideoPlayRet, eMsgSig_VideoPlayRet, ret);
	}
}

int CLocalMediaPlayEntity::GetMediaPlayerIcoPath(char* strPath, int iLen)
{
	return GetPlayerIcoPath(strPath, iLen);
}

int CLocalMediaPlayEntity::GetAudioOutDevName(char* strDev, int iLen)
{
	int iRet = -1;
	
	int idatalen = m_strAudioOutDev.GetLength();
	if (iLen > idatalen && idatalen > 0) {
		memcpy(strDev, m_strAudioOutDev.GetData(), idatalen);
		iRet = 0;
		if (false == m_bgetflag) {
			m_bgetflag = true;
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d audio Out Device Name is %s.", __FUNCTION__, __LINE__, strDev);
		}
	}

	return iRet;
}


int CLocalMediaPlayEntity::PlayingAudioDataCallback(audio_param_t* param, const void* input, unsigned long uaudiolen)
{
	int iRet = -1;

	if (0 != m_iPlayType && m_bStartRecord) {
		if (false == m_bloged) {
			m_bloged = true;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_PLAYING_AUDIO_INFOS, CSimpleStringA::Format("audio param target (%d channels, %d Hz, channel_layout(%d), frame_size(%d), bytes_per_sec(%d), audio format(%d)).", param->channels, param->freq, param->channel_layout, param->frame_size, param->bytes_per_sec, param->fmt).GetData());
		}

		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d uaudiolen:%d", __FUNCTION__, __LINE__, uaudiolen);
		//AV_SAMPLE_FMT_S16 == 1
		if (1 == param->fmt) {	
			int isingle_audioframe_len = param->bytes_per_sec/50;
			int ioffset = 0;
			int icount = (uaudiolen + m_leftlen) / isingle_audioframe_len;
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d icount:%d, isingle_audioframe_len = %d.", __FUNCTION__, __LINE__, icount, isingle_audioframe_len);
			if (icount > 0) {
				for (int i = 0; i < icount; i++) {
					audio_frame frm;
					char* straudio = new char[isingle_audioframe_len];
					if (m_leftlen > 0){
						memcpy(straudio, m_audiobuffer, m_leftlen);
						memcpy(straudio + m_leftlen, (char*)input, isingle_audioframe_len - m_leftlen);
						ioffset += (isingle_audioframe_len - m_leftlen);
						m_leftlen = 0;
					}
					else{
						memcpy(straudio, (char*)input + ioffset, isingle_audioframe_len);
						ioffset += isingle_audioframe_len;
					}
						
					frm.bitspersample = 16;
					frm.format = param->fmt;
					frm.data = straudio;
					frm.framesize = isingle_audioframe_len;
					frm.nchannels = param->channels;
					frm.samplespersec = param->freq;
					frm.iseriesnumber = m_iseriesnumber++;
					
					if (1 == frm.nchannels && 8000 == frm.samplespersec){
						if (!m_remote_audio_queue->InsertAudio(&frm)) {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
						}
						else {
							//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d InsertAudio(series number = %d) success and framesize = %d.", __FUNCTION__, __LINE__, frm.iseriesnumber, frm.framesize);
							if (m_bRecordPCM && m_pFile){
								fwrite(frm.data, isingle_audioframe_len, 1, m_pFile);
							}
						}
					} 
					else{
						char strsingle[RVC_AUDIO_LEN*2] = {0};
						uint32_t uLen = PcmConvert(strsingle, RVC_AUDIO_LEN*2, straudio, isingle_audioframe_len, frm.samplespersec, frm.nchannels);
						frm.data = strsingle;
						frm.framesize = RVC_AUDIO_LEN;
						frm.nchannels = 1;
						if (!m_remote_audio_queue->InsertAudio(&frm)) {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
						}
					}
						
					delete []straudio;
				}
				memset(m_audiobuffer, 0, RVC_AUDIO_BUFFER_LEN);
				int ileftaudio = uaudiolen - ioffset;
				memcpy(m_audiobuffer, (char*)input + ioffset, ileftaudio);
				m_leftlen = ileftaudio;
			}
			else {
				memcpy(m_audiobuffer + m_leftlen, (char*)input , uaudiolen);
				m_leftlen += uaudiolen;
			}	
			iRet = 0;
		}
	}

	return iRet;
}

int CLocalMediaPlayEntity::GetPicPlayerIcoPath(char* strPath, int uLen)
{
	return GetPlayerIcoPath(strPath, uLen);
}


bool CLocalMediaPlayEntity::GetPlayFlag()
{
	return m_badplayflag;
}


bool CLocalMediaPlayEntity::GetScanExitFlag()
{
	return m_scanexitflag;
}

DeviceTypeEnum CLocalMediaPlayEntity::GetDeviceType()
{
	return m_eDeviceType;
}

int CLocalMediaPlayEntity::GetPlayerIcoPath(char* strPath, int iLen)
{
	int iRet = -1;
	if (NULL == strPath) {
		return iRet;
	}
	
	CSimpleStringA csBinPath;
	ErrorCodeEnum eErrPath = GetFunction()->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetBasePath failed (%d).", eErrPath);
		return iRet;
	}

	CSimpleStringA szIcoName("rvc_media_player_64px.bmp");
	szIcoName = csBinPath + SPLIT_SLASH_STR + szIcoName;
	if (m_bgetico == false) {
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("media player ico full path is %s.", szIcoName.GetData());
		m_bgetico = true;
	}

	if (iLen > szIcoName.GetLength()) {
		memcpy(strPath, szIcoName.GetData(), szIcoName.GetLength());
		iRet = 0;
		m_bgetico = true;
	}
	
	return iRet;
}


int CLocalMediaPlayEntity::GetAudioOutDev()
{
	int iRet = -1;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spRootConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spRootConfig);
	if (Error == Error_Succeed) {
		SpIniMappingTable table;
		table.AddEntryString("audio", "handfree_out_dev", m_strAudioOutDev, "$");
		Error = table.Load(spRootConfig);
		if (Error == Error_Succeed) {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Audio Out Device name is %s.", m_strAudioOutDev.GetData());
			iRet = 0;
		}
	}
	return iRet;
}


ErrorCodeEnum CLocalMediaPlayEntity::LoadEntityConfig()
{
	SpIniMappingTable table;
	int iPlayType = 0;
	int iMediaLogLevel = (int)MEDIA_LOG_INFO;
	int iPicLogLevel = (int)PIC_LOG_INFO;
	bool bRecordPCM = false;
	table.AddEntryInt("LocalMediaPlay", "PlayType", iPlayType, 0);
	table.AddEntryInt("LocalMediaPlay", "MediaLevel", iMediaLogLevel, (int)MEDIA_LOG_INFO);
	table.AddEntryInt("LocalMediaPlay", "PicLevel", iPicLogLevel, (int)PIC_LOG_INFO);
	table.AddEntryBoolean("SalesRecorder", "IsRecordPCM", bRecordPCM, false);

	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed) {
		Error = table.Load(spConfig);
		if (Error_Succeed == Error){
			m_iPlayType = iPlayType;

			if (iMediaLogLevel <= MEDIA_LOG_ERROR && iMediaLogLevel > 0){
				m_medialevel = (media_loglevel)iMediaLogLevel;
			}

			if (iPicLogLevel <= PIC_LOG_ERROR && iPicLogLevel > 0) {
				m_piclevel = (pic_loglevel)iPicLogLevel;
			}

			if (bRecordPCM) {
				m_bRecordPCM = true;
			}
		}
	}

#ifdef RVC_OS_LINUX
	m_iPlayType = 1;
#endif // RVC_OS_LINUX

	return Error;
}


void CLocalMediaPlayEntity::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)
{
	if (LOG_EVT_HEALTHMANAGER_BROWSER_IDLE == dwUserCode){
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IEBrowser to idle, stop all media!");
		StopAll();
	}
	else if(LOG_EVT_UI_STARTREMOTERECORD == dwUserCode){
		if (0 != m_iPlayType){
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Start remote record.");
			HandleRemoteRecord(pszMessage);
		}
	}
	else if (LOG_EVT_UI_STOPREMOTERECORD == dwUserCode) {
		if (0 != m_iPlayType){
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop remote record.");
			m_bStartRecord = false;
			m_iseriesnumber = 0;
			m_leftlen = 0;
			if (NULL != m_remote_audio_queue) {
				delete m_remote_audio_queue;
				m_remote_audio_queue = NULL;
			}

			if (m_pFile) {
				fclose(m_pFile);
				m_pFile = NULL;
			}
		}
	}
}


void CLocalMediaPlayEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
{
	ErrorCodeEnum Error = __OnStart(Error_Succeed);

	pTransactionContext->SendAnswer(Error);
}

ErrorCodeEnum CLocalMediaPlayEntity::__OnStart(ErrorCodeEnum preOperationError)
{
	SetLogFlag(false);
	SetLocalLogFlag(false);
	SetLocalPicLogFlag(false);
	m_eDeviceType = RvcGetDeviceType();

	if (Error_Succeed != LoadEntityConfig()){
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("LoadEntityConfig failed.");
	}

	return Error_Succeed;
}

void CLocalMediaPlayEntity::OnStarted()
{
	LogEvent(Severity_Middle, LOG_EVT_MOD_LOCALPLAYER_STARTED_SUCCESS, "local meida play entity started successfully.");
	
	GetAudioOutDev();

	for (int i = 0; i != MAX_PLAY_CHANNELS; ++i)
	{
#ifdef RVC_OS_WIN
		m_pVideoPlayer[i] = new Clibwmpplayer(this);
		m_pImagePlayer[i] = new Clibimgplayer(this);
#endif
		mediaplayer_init();
		m_pMediaPlayer[i] = new Clibmediaplayer(this);
		m_pPicturePlayer[i] = new Clibpictureplayer(this);
	}
	
	m_pMediaAudioPlayer = new Clibmediaplayer(this);
#ifdef RVC_OS_WIN
	m_pAudioPlayer = new Clibwmpplayer(this);
#else
	signal(SIGTERM, sig_handler);
#endif // RVC_OS_WIN

	if (!IsRunConfigExist()){
		SetLocalVideoVolume(0, 50);
		SetLocalAudioVolume(50);
	}

	setMediaPath();
	if (eStand2sType == m_eDeviceType) {
		loadDefaultMedia(0 != m_iPlayType);
	}

	GetFunction()->SubscribeLog(m_SubIDIEIdle, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_HEALTHMANAGER_BROWSER_IDLE, NULL, false);
	GetFunction()->SubscribeLog(m_SubIDStartRecord, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTREMOTERECORD, NULL, false);
	GetFunction()->SubscribeLog(m_SubIDStopRecord, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPREMOTERECORD, NULL, false);

	if (eStand2sType == m_eDeviceType) {
#ifdef RVC_OS_WIN
		m_scanThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&qryMedia, this, 0, NULL);
		if (NULL != m_scanThread)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create qryMeia thread success, %d.", m_scanThread);
#else
		int err = pthread_create(&m_scanThreadId, NULL, queryMedia, this);
		if (0 != err) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create queryMedia thread failed.");
		}
#endif // RVC_OS_WIN
	}
}

void CLocalMediaPlayEntity::OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext)
{
	ErrorCodeEnum Error = __OnClose(Error_Succeed);
	pTransactionContext->SendAnswer(Error);
}

ErrorCodeEnum CLocalMediaPlayEntity::__OnClose(ErrorCodeEnum preOperationError)
{
	for (int i = 0; i != MAX_PLAY_CHANNELS; ++i)
	{
#ifdef RVC_OS_WIN
		delete m_pVideoPlayer[i];
		m_pVideoPlayer[i] = NULL;

		delete m_pImagePlayer[i];
		m_pImagePlayer[i] = NULL;
#endif // RVC_OS_WIN

		delete m_pMediaPlayer[i];
		m_pMediaPlayer[i] = NULL;

		delete m_pPicturePlayer[i];
		m_pPicturePlayer[i] = NULL;
	}

#ifdef RVC_OS_WIN
	delete m_pAudioPlayer; 
	m_pAudioPlayer = NULL;
#endif

	delete m_pMediaAudioPlayer;
	m_pMediaAudioPlayer = NULL;
	
	GetFunction()->UnsubscribeLog(m_SubIDIEIdle);
	GetFunction()->UnsubscribeLog(m_SubIDStartRecord);
	GetFunction()->UnsubscribeLog(m_SubIDStopRecord);

	// 释放播放对象
	if (0 != m_iPlayType){
		mediaplayer_term();
	}

	return Error_Succeed;
}


ErrorCodeEnum CLocalMediaPlayEntity::HandleRemoteRecord(const char* pszMessage)
{
	ErrorCodeEnum Error = Error_Succeed;
	m_bStartRecord = true;
	memset(m_audiobuffer, 0, RVC_AUDIO_LEN);
	m_leftlen = 0;
	m_remote_audio_queue = new Clibaudioqueue(REC_COMMON_REMOTEAUDIO_SHM_QUEUE);
	m_iseriesnumber = 0;
	m_bloged = false;

	if (true == m_bRecordPCM){
		char strSwiftName[MAX_PATH] = { 0 };
		if (NULL != pszMessage) {
			size_t ulen = strlen(pszMessage);
			char* tmp = new char[ulen + 1];
			memset(tmp, 0, ulen + 1);
			memcpy(tmp, pszMessage, ulen);

			char* result[16] = { 0 };
			auto arr1 = CSimpleStringA2W(tmp).Split('@');
			auto arr2 = CAutoArray<CSimpleStringA>(arr1.GetCount());
			for (int i = 0; i < arr1.GetCount(); ++i) {
				arr2[i] = CSimpleStringW2A(arr1[i]);
				result[i] = const_cast<LPSTR>(arr2[i].GetData());
			}
			if (arr1.GetCount() > 4) {
#ifdef RVC_OS_WIN
				_snprintf(strSwiftName, MAX_PATH, "%s", result[4]);
#else
				snprintf(strSwiftName, MAX_PATH, "%s", result[4]);
#endif // RVC_OS_WIN
			}
			delete tmp;
			tmp = NULL;
		}

		CSimpleStringA strTempDir("");
		CSimpleStringA strName("");
		if (Error_Succeed == GetFunction()->GetPath("Temp", strTempDir)) {
			strName = CSimpleStringA::Format("%s/remote_audio_notice_%s.pcm", strTempDir.GetData(), strSwiftName);
		}
		else {
			strName = CSimpleStringA::Format("remote_audio_notice_%s.pcm", strSwiftName);
		}

		m_pFile = fopen(strName.GetData(), "wb+");
		if (NULL == m_pFile) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("fopen %s failed.", strName.GetData());
		}
	}

	return Error;
}

#ifdef RVC_OS_WIN
DWORD WINAPI CheckAudioThread(LPVOID param)
{
	CLocalMediaPlayEntity *entity = (CLocalMediaPlayEntity*)param;

	HANDLE playEndEvent = NULL;
	if (!entity->m_pAudioPlayer->checkIsPlay(playEndEvent)){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play audio Media Thread Failed!");
		return 0;
	}

	BOOL bPlayFinished = FALSE;
	for (;;) {
		DWORD dwRet = WaitForSingleObject(playEndEvent, 100);
		if (dwRet == WAIT_OBJECT_0) { // exit
			bPlayFinished = TRUE;
			break;
		} 
		else { // timeout
			if (entity->m_pAudioPlayer->checkIsStop()){
				break;
			}
		}
	}

	entity->m_pAudioPlayer->Close();

	if (bPlayFinished){
		AudioPlayRet ret;
		ret.AudioNames = entity->m_lastPlayAudio.c_str();
		ret.ret = true;
		//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("stop play audio %s success", ret.AudioNames);
		SpSendBroadcast(entity->GetFunction(), eMsg_AudioPlayRet, eMsgSig_AudioPlayRet, ret);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SpSendBroadcast AudioPlayRet and audio name is %s.", ret.AudioNames.GetData());
	}

	entity->m_lastPlayAudio.clear();

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("End CheckAudioThread");
	
	return 0;
}


DWORD WINAPI StartAudioPlayingThreadFunc(LPVOID param)
{
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter StartAudioPlayingThreadFunc");
	const char* pAudioNames = entity->m_lastPlayAudio.c_str();
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Begin StartAudio, and Audio Info is %s.", pAudioNames);
	if (0 != entity->m_pMediaAudioPlayer->PlayLocalAudio(pAudioNames)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("StartAudio failed, for %s is not exist.", pAudioNames);
	}
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Leave StartAudioPlayingThreadFunc");
	entity->m_uMediaPlayThreadId = NULL;

	return 0;
}

DWORD WINAPI NoticePlayThread(LPVOID param)
{
	CLocalMediaPlayEntity *entity = (CLocalMediaPlayEntity*)param;
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Begin NoticePlayThread");

	HANDLE playEndEvent = NULL;
	if (!entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playEndEvent)){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get notice play end event failed!");
		return 0;
	}

	bool bPlayFinished = FALSE;
	for (;;) {
		DWORD dwRet = WaitForSingleObject(playEndEvent, 100);
		if (dwRet == WAIT_OBJECT_0) { // exit
			bPlayFinished = true;
			break;
		} 
		else { // timeout
			if (entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){
				break;
			}
		}
	}

	entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->Close();

	if (bPlayFinished){
		VideoPlayRet ret;
		ret.VideoNames = entity->m_lastPlayVideo.c_str();
		ret.ret = true;
		SpSendBroadcast(entity->GetFunction(), eMsg_VideoPlayRet, eMsgSig_VideoPlayRet, ret);
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_PLAY_FINISHED, CSimpleStringA::Format("notice %s play finished.", ret.VideoNames.GetData()).GetData());
	}
	else{
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_PLAY_EARLY_TERM, CSimpleStringA::Format("notice %s play early terminate.", entity->m_lastPlayVideo.c_str()).GetData());
	}

	entity->m_lastPlayVideo.clear();

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("End NoticePlayThread");

	return 0;
}


DWORD WINAPI MediaPlayThread(LPVOID param)
{
	CLocalMediaPlayEntity *entity = (CLocalMediaPlayEntity*)param;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter Windows Media Play Thread.");

	while (entity->GetPlayFlag())
	{
		vector<ResourceParse> curParse;
		entity->m_mediaManage.GetPlayListByLocal(curParse);
		unsigned int ustart_time = y2k_time_now();

		if (0 == curParse.size())
		{
			HANDLE playThread = NULL;
			CWmpPlayConfig config;
			ZeroMemory(&config, sizeof(CWmpPlayConfig));
			memcpy(&config, &(entity->m_defaultVideo[entity->m_mediaParam.nCfgInx]), sizeof(CWmpPlayConfig));
			config.nPlayCnt = 1;	//can be change 
			config.eMode = LOCALVIDEO;
			config.nWndX = entity->m_mediaParam.nWndX;
			config.nWndY = entity->m_mediaParam.nWndY;
			config.nWndWidth = entity->m_mediaParam.nWndWidth;
			config.nWndHeight = entity->m_mediaParam.nWndHeight;
			config.bPrimMonitor = false;
			if (IS_DEBUG){
				config.bFullScreen = false;
				config.bPrimMonitor = true;
			}

			CSimpleStringA strVideoPath = config.strRootPath;
			CSimpleStringA strVideoFileName = config.strFileNames[0];
			CSimpleStringA strVideoFullPath = strVideoPath + strVideoFileName;
			bool bRet = ExistsFileA(strVideoFullPath.GetData());
			if (false == bRet && false == entity->GetLogFlag()){
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_VIDEO_NOT_EXIST, CSimpleStringA::Format("adv video file %s not exist!", strVideoFullPath.GetData()).GetData());
				entity->SetLogFlag(true);
			}

			if (false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E) || false == bRet){
				Sleep(1000);
				continue;
			}

			if (!entity->GetLocalVideoVolume(0, config.nVolume)){
				config.nVolume = entity->m_defaultVolum;
			}
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
			entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
			if (!entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread)){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get Play End Event Failed!");
			}
			else{
				WaitForSingleObject(playThread, INFINITE);
				if (entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){//停止播放
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video");
				}
				else{
					entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->Close();
				}
			}
		}
		else
		{
			for (vector<ResourceParse>::iterator i = curParse.begin(); i != curParse.end() && entity->GetPlayFlag(); i++)
			{
				HANDLE playThread = NULL;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin play extend [Media] %c:%s, %s", i->type, i->resourcePath.c_str(), i->videoNames.c_str());
				if ('V' == i->type)
				{//video
					CWmpPlayConfig config;
					ZeroMemory(&config, sizeof(CWmpPlayConfig));
					config.bFullScreen = IS_DEBUG ? false : i->fullScreen;
					config.bPrimMonitor = IS_DEBUG ? true : false;
					config.bSimpleMode = i->simpleMode;
					config.eMode = LOCALVIDEO;
					config.nFileCnt = 1;
					config.nPlayCnt = 1;
					config.nPlayInterval = i->playInterval;

					if (!entity->GetLocalVideoVolume(0, config.nVolume)){
						config.nVolume = entity->m_defaultVolum;
					}
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
					config.nWndX = entity->m_mediaParam.nWndX;
					config.nWndY = entity->m_mediaParam.nWndY;
					config.nWndWidth = entity->m_mediaParam.nWndWidth;
					config.nWndHeight = entity->m_mediaParam.nWndHeight;
					strncpy_s(config.strRootPath, i->resourcePath.c_str(), sizeof(config.strRootPath));
					strncpy_s(config.strFileNames[0], i->videoNames.c_str(), 256);
					strncpy_s(config.strVideoRunTime_S, "09:00:00", sizeof(config.strVideoRunTime_S));
					strncpy_s(config.strVideoRunTime_E, "17:30:00", sizeof(config.strVideoRunTime_E));
					if (false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E)) {
						Sleep(3000);
						continue;
					}

					CSimpleStringA strVideoPath = config.strRootPath;
					CSimpleStringA strVideoFileName = config.strFileNames[0];
					CSimpleStringA strVideoFullPath = strVideoPath + strVideoFileName;
					bool bRet = ExistsFileA(strVideoFullPath.GetData());
					bool bFileValid = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->IsFileValid(strVideoFullPath.GetData());

					if (false == bRet && false == entity->GetLocalLogFlag()){
						LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_VIDEO_NOT_EXIST, CSimpleStringA::Format("adv video file %s not exist!", strVideoFullPath.GetData()).GetData());
						entity->SetLocalLogFlag(true);
					}

					if(false == bRet || false == bFileValid){
						continue;
					}

					entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
					if (!entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread)){
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get Play End Event Failed!");
					}
					else{
						WaitForSingleObject(playThread, INFINITE);
						if (entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){//停止播放
							//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play video");
						}
						else{
							entity->m_pVideoPlayer[entity->m_mediaParam.nCfgInx]->Close();
						}
					}
				}
				else if ('P' == i->type)
				{//play Image
					CImgPlayConfig config;
					ZeroMemory(&config, sizeof(CImgPlayConfig));
					config.bFullScreen = IS_DEBUG ? false : i->fullScreen;
					config.bPrimMonitor = IS_DEBUG ? true : false;
					config.nFileCnt = 1;
					config.nPlayCnt = 1;
					config.nPlayInterval = i->playInterval;
					config.nWndX = entity->m_mediaParam.nWndX;
					config.nWndY = entity->m_mediaParam.nWndY;
					config.nWndWidth = entity->m_mediaParam.nWndWidth;
					config.nWndHeight = entity->m_mediaParam.nWndHeight;
					strncpy_s(config.strRootPath, i->resourcePath.c_str(), sizeof(config.strRootPath));
					strncpy_s(config.strFileNames[0], i->videoNames.c_str(), 256);

					CSimpleStringA strPicPath = config.strRootPath;
					CSimpleStringA strPicFileName = config.strFileNames[0];
					CSimpleStringA strPicFullPath = strPicPath + strPicFileName;
					bool bRet = ExistsFileA(strPicFullPath.GetData());
					if (false == bRet && false == entity->GetLocalPicLogFlag()){
						LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_PIC_NOT_EXIST, CSimpleStringA::Format("adv picture file %s not exist!", strPicFullPath.GetData()).GetData());
						entity->SetLocalPicLogFlag(true);
					}

					if(false == bRet){
						continue;
					}

					entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
					if (!entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(playThread)){
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Image Media Thread Failed!");
					}
					else
					{
						WaitForSingleObject(playThread, i->playInterval);
						if (entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){//停止播放
							//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play Image");
						}
						else{
							entity->m_pImagePlayer[entity->m_mediaParam.nCfgInx]->Close();
						}
					}
				}
			}
		}

		unsigned int uend_time = y2k_time_now();
		if (uend_time - ustart_time < RVC_MIN_LOCALPLAYER_TIME) {
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIAPLAY_COST_TIME_ERROR, "广告播放错误，播放时长不足1秒");
			break;
		}
	}

	if (entity->m_badplayflag) {
		entity->m_badplayflag = false;
	}
	
	if (entity->m_playThread) {
		entity->m_playThread = NULL;
	}
	
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Exit MediaPlayThread.");

	return 0;
}


DWORD WINAPI StartMediaPlayFunc(LPVOID param)
{
	int iRet = -1;
	if (NULL == param){
		return iRet;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter FFmpeg Media Play Function.");

	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	while (entity->GetPlayFlag())
	{
		vector<ResourceParse> curParse;
		entity->m_mediaManage.GetPlayListByLocal(curParse);
		unsigned int ustart_time = y2k_time_now();

		if (0 == curParse.size()){
			CMediaPlayConfig config = {0};
			memcpy(&config, &(entity->m_Videos[entity->m_mediaParam.nCfgInx]), sizeof(CMediaPlayConfig));
			config.nPlayCnt = 1;	//can be change 
			config.eMode = MEDIA_LOCALVIDEO;
			config.nWndX = entity->m_mediaParam.nWndX;
			config.nWndY = entity->m_mediaParam.nWndY;
			config.nWndWidth = entity->m_mediaParam.nWndWidth;
			config.nWndHeight = entity->m_mediaParam.nWndHeight;
			config.bPrimMonitor = false;
			if (IS_DEBUG){
				config.bFullScreen = false;
				config.bPrimMonitor = true;
			}

			if (!entity->GetLocalVideoVolume(0, config.nVolume)){
				config.nVolume = entity->m_defaultVolum;
			}

			if(false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E)){
				Sleep(1000);
				continue;
			}

			if (-1 == entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config)){
				Sleep(3000);
			}
			Sleep(800);
		}

		for (int i = 0; i < curParse.size() && entity->GetPlayFlag(); i++)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ResourceList[%d] address is 0x%0x", i, ResourceList[i]);
			HANDLE playThreadId = 0;
			ResourceParse item = curParse[i];
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin play extend [Media%d] %c:%s, %s",i, item.type, item.resourcePath.c_str(), item.videoNames.c_str());
			if ('V' == item.type)
			{//video
				CMediaPlayConfig config = {0};
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : false;
				config.bSimpleMode = item.simpleMode;
				config.eMode = MEDIA_LOCALVIDEO;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				if (!entity->GetLocalVideoVolume(0, config.nVolume)){
					config.nVolume = entity->m_defaultVolum;
				}

				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("config.nVolume=%d while play local video.", config.nVolume);
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.resourcePath.c_str(), item.resourcePath.length() < MAX_PATH ? item.resourcePath.length() : MAX_PATH);
				strncpy(config.strFileNames[0], item.videoNames.c_str(), item.videoNames.length() < MAX_PATH ? item.videoNames.length() : MAX_PATH);
				strncpy(config.strVideoRunTime_S, "09:00:00", sizeof(config.strVideoRunTime_S));
				strncpy(config.strVideoRunTime_E, "17:30:00", sizeof(config.strVideoRunTime_E));
				
				if (false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E)){
					Sleep(3000);
					continue;
				}

				int iPlayRet = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
				if (-3 == iPlayRet) {
					Sleep(DEFAULT_SLEEP_TIME);
				}
				Sleep(800);
			}
			else if ('P' == item.type)
			{//play Image
				//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Begin new Image play, entity->m_mediaParam.nCfgInx = %d.", entity->m_mediaParam.nCfgInx);
				CPicPlayConfig config = {0};
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : false;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.resourcePath.c_str(), item.resourcePath.length() < MAX_PATH ? item.resourcePath.length() : MAX_PATH);
				strncpy(config.strFileNames[0], item.videoNames.c_str(), item.videoNames.length() < MAX_PATH ? item.videoNames.length() : MAX_PATH);
				if (entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){
					entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
					if (!entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(&playThreadId)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Image Media Thread Failed!");
						iRet = -1;
						return iRet;
					}
					//else { 
					//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Image Media Player Thread id is 0x%p.", playThreadId);
					//}

					WaitForSingleObject(playThreadId, INFINITE);
					if (entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()){//停止播放
						//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("stop play video");
					}
					else{
						entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->Close();
					}
				}
				Sleep(100);
			}
		}
		unsigned int uend_time = y2k_time_now();
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("uend_time - ustart_time = %u.", uend_time - ustart_time);
		if (uend_time - ustart_time < RVC_MIN_LOCALPLAYER_TIME) {
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIAPLAY_COST_TIME_ERROR, "广告播放错误，播放时长不足1秒");
			break;
		}
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Leave Media Play Function.");

	if (entity->m_badplayflag) {
		entity->m_badplayflag = false;
	}

	if (0 != entity->m_uMediaPlayThreadId) {
		entity->m_uMediaPlayThreadId = 0;
	}

	return iRet;
}
#else
void* StartAudioPlayingThreadFunc(void* param)
{
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	const char* pAudioNames = entity->m_lastPlayAudio.c_str();
	if (0 != entity->m_pMediaAudioPlayer->PlayLocalAudio(pAudioNames)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("StartAudio failed, for %s is not exsit.", pAudioNames);
	}

	entity->m_uMediaPlayThreadId = 0;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Exit Start Audio Playing Thread Function.");

	return 0;
}


void* StartMediaPlayFunc(void* param)
{
	int iRet = -1;
	if (NULL == param) {
		return (void*)&iRet;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter FFmpeg Media Play Function.");

	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	while (entity->GetPlayFlag())
	{
		rvcResourceParse_t ResourceList[MAX_LOCAL_MEDIAS] = { 0 };
		size_t uCount = entity->m_mediaManage.GetPlayListByLocal(ResourceList, MAX_LOCAL_MEDIAS);
		unsigned int ustart_time = y2k_time_now();

		if (0 == uCount) {
			int64_t playThreadId = 0;
			CMediaPlayConfig config = { 0 };
			memcpy(&config, &(entity->m_Videos[entity->m_mediaParam.nCfgInx]), sizeof(CMediaPlayConfig));
			config.nPlayCnt = 1;	//can be change 
			config.eMode = MEDIA_LOCALVIDEO;
			config.nWndX = entity->m_mediaParam.nWndX;
			config.nWndY = entity->m_mediaParam.nWndY;
			config.nWndWidth = entity->m_mediaParam.nWndWidth;
			config.nWndHeight = entity->m_mediaParam.nWndHeight;
			config.bPrimMonitor = false;
			if (IS_DEBUG) {
				config.bFullScreen = false;
				config.bPrimMonitor = true;
			}

			if (!entity->GetLocalVideoVolume(0, config.nVolume)) {
				config.nVolume = entity->m_defaultVolum;
			}

			if (false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E)){
				Sleep(10000);
				continue;
			}

			if (-1 == entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config)) {
				Sleep(30 * DEFAULT_SLEEP_TIME);
			}
			Sleep(800);
		}

		for (int i = 0; i < uCount && i < MAX_LOCAL_MEDIAS && entity->GetPlayFlag(); i++)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ResourceList[%d] address is 0x%0x", i, ResourceList[i]);
			int64_t playThreadId = 0;
			rvcResourceParse_t item = ResourceList[i];
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin play extend %c:%s, %s", item.type, item.strResourcePath, item.strvideoNames);
			if ('V' == item.type)
			{//video
				CMediaPlayConfig config = { 0 };
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : false;
				config.bSimpleMode = item.simpleMode;
				config.eMode = MEDIA_LOCALVIDEO;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				if (!entity->GetLocalVideoVolume(0, config.nVolume)) {
					config.nVolume = entity->m_defaultVolum;
				}

				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.strResourcePath, strlen(item.strResourcePath));
				strncpy(config.strFileNames[0], item.strvideoNames, strlen(item.strvideoNames));
				strncpy(config.strVideoRunTime_S, "09:00:00", sizeof(config.strVideoRunTime_S));
				strncpy(config.strVideoRunTime_E, "17:30:00", sizeof(config.strVideoRunTime_E));
				
				if (false == IsValidPlayTime(config.strVideoRunTime_S, config.strVideoRunTime_E)) {
					Sleep(DEFAULT_SLEEP_TIME);
					continue;
				}

				int iPlayRet = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
				if (-3 == iPlayRet) {
					Sleep(DEFAULT_SLEEP_TIME / 6);
				}
				Sleep(800);
			}
			else if ('P' == item.type)
			{//play Image
				CPicPlayConfig config = { 0 };
				config.bFullScreen = IS_DEBUG ? false : item.fullScreen;
				config.bPrimMonitor = IS_DEBUG ? true : false;
				config.nFileCnt = 1;
				config.nPlayCnt = 1;
				config.nPlayInterval = item.playInterval;
				config.nWndX = entity->m_mediaParam.nWndX;
				config.nWndY = entity->m_mediaParam.nWndY;
				config.nWndWidth = entity->m_mediaParam.nWndWidth;
				config.nWndHeight = entity->m_mediaParam.nWndHeight;
				strncpy(config.strRootPath, item.strResourcePath, strlen(item.strResourcePath));
				strncpy(config.strFileNames[0], item.strvideoNames, strlen(item.strvideoNames));
				if (entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsStop()) {
					entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->PlayMedia(config);
					if (!entity->m_pPicturePlayer[entity->m_mediaParam.nCfgInx]->checkIsPlay(&playThreadId)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Create play Image Media Thread Failed!");
						iRet = -1;
						return (void*)&iRet;
					}

					if (0 == pthread_join(playThreadId, NULL)) {
						iRet = 0;
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pthread join thread id %u failed for %s.", playThreadId, strerror(errno));
						iRet = -1;
					}
				}
				Sleep(100);
			}
		}
		unsigned int uend_time = y2k_time_now();
		if (uend_time - ustart_time < RVC_MIN_LOCALPLAYER_TIME) {
			Sleep(30 * DEFAULT_SLEEP_TIME);
		}
	}
	entity->m_uMediaPlayThreadId = 0;
	
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Leave Media Play Function.");

	return (void*)&iRet;
}


void* StartNoticePlayThreadFunc(void* param)
{
	int iRet = -1;
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	const char* pVideoName = entity->m_lastPlayVideo.c_str();

	Clibmediaplayer* player = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx];
	player->PlayVideoNotice(entity->m_mediaParam.nWndX, entity->m_mediaParam.nWndY, entity->m_mediaParam.nWndWidth, entity->m_mediaParam.nWndHeight, pVideoName);
	entity->m_uNoticePlayThreadId = 0;

	iRet = 0;

	return (void*)&iRet;
}

#endif


DeviceTypeEnum CLocalMediaPlayEntity::RvcGetDeviceType()
{
	DeviceTypeEnum eType = eStand2sType;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSystemStaticInfo stStaticinfo;
	spFunction->GetSystemStaticInfo(stStaticinfo);
	if (_stricmp(stStaticinfo.strMachineType, "RVC.Stand1SPlus") == 0) {
		eType = eStand1SPlusType;
	}
	else if (_stricmp(stStaticinfo.strMachineType, "RVC.CardStore") == 0 || _stricmp(stStaticinfo.strMachineType, "RVC.CardPrinter") == 0) {
		eType = eCardStore;
	}
	else {
		eType = eStand2sType;
	}

	if (eType >= 0 && eType < sizeof(Device_Type_Table) / sizeof(char*)) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("device type is %s.", Device_Type_Table[eType]);
	}

	return eType;
}


void CLocalMediaPlayEntity::StartVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	if(eStand2sType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StartVideo!");
			return;
		}

		m_mediaParam.nCfgInx = nCfgInx;
		m_mediaParam.nWndX = nWndX;
		m_mediaParam.nWndY = nWndY;
		m_mediaParam.nWndWidth = nWndWidth;
		m_mediaParam.nWndHeight = nWndHeight;

#ifdef RVC_OS_WIN
		if (0 == m_iPlayType) {
			if (NULL != m_playThread) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Current is playing video, close it.");
				StopVideo(nCfgInx);
			}

			if (NULL == m_playThread) {
				m_badplayflag = true;
				m_playThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&MediaPlayThread, this, 0, NULL);
			}
		}
		else {
			if (NULL != m_uMediaPlayThreadId) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Current is playing video, close it.");
				StopVideo(nCfgInx);
			}

			m_badplayflag = true;
			m_uMediaPlayThreadId = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&StartMediaPlayFunc, this, 0, NULL);
		}
#else
		m_badplayflag = true;
		int err = pthread_create(&m_uMediaPlayThreadId, NULL, StartMediaPlayFunc, this);
		if (0 != err) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create media play thread failed.");
		}
#endif // RVC_OS_WIN
	}
}

void CLocalMediaPlayEntity::StartAudio(const char *pAudioNames)
{
#ifdef RVC_OS_WIN
	if (0 == m_iPlayType) {
		static HANDLE audioPlayThread = NULL;
		if (audioPlayThread)//关闭正在播放的音频
		{
			DWORD exitCode = 0;
			if (WAIT_TIMEOUT == WaitForSingleObject(audioPlayThread, 500)) {
				//TerminateThread(audioPlayThread, exitCode);
				m_pAudioPlayer->Close();
			}
			audioPlayThread = NULL;
		}

		if (NULL != pAudioNames) {
			char strAudios[MAX_PATH] = { 0 };
			_snprintf(strAudios, MAX_PATH, "%s", pAudioNames);
			const char* d = "|";
			char* pName = NULL;
			char* pdata = NULL;
			pName = strtok_s(strAudios, d, &pdata);
			while (pName) {
				CSimpleStringA strAudioFileName = pName;
				CSimpleStringA strAudioFullPath = m_AudioPath + strAudioFileName;
				if (!ExistsFileA(strAudioFullPath.GetData())) {
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_ADV_AUDIO_NOT_EXIST, CSimpleStringA::Format("audio file %s not exist!", strAudioFullPath.GetData()).GetData());
					return;
				}
				pName = strtok_s(NULL, d, &pdata);
			}
		}

		m_pAudioPlayer->PlayLocalAudio(pAudioNames);

		auto audioRet = GetLocalAudioVolume();
		m_pAudioPlayer->SetVolume(audioRet.second);

		m_lastPlayAudio = pAudioNames;
		audioPlayThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&CheckAudioThread, this, 0, NULL);
	}
	else
	{
		if (m_pMediaAudioPlayer->checkIsPlay()) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("current is playing, close it.");
			if (0 != m_uMediaPlayThreadId) {
				m_pMediaAudioPlayer->Close();
				m_uMediaPlayThreadId = 0;
				Sleep(500);
			}
		}
		m_lastPlayAudio = pAudioNames;
		m_uMediaPlayThreadId = CreateThread(NULL, 0, StartAudioPlayingThreadFunc, this, 0, NULL);
		m_buserstopaudio = false;
		auto audioRet = GetLocalAudioVolume();
		m_pMediaAudioPlayer->SetVolume(audioRet.second);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to set audio volume %d!", audioRet.second);
	}
#else
	if (m_pMediaAudioPlayer->checkIsPlay()) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("current is playing, close it.");
		if (0 != m_uMediaPlayThreadId) {
			m_pMediaAudioPlayer->Close();
			pthread_join(m_uMediaPlayThreadId, NULL);

		}
	}

	m_lastPlayAudio = pAudioNames;

	int err = pthread_create(&m_uMediaPlayThreadId, NULL, StartAudioPlayingThreadFunc, this);
	if (0 != err) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio play thread failed.");
	}

	m_buserstopaudio = false;

	auto audioRet = GetLocalAudioVolume();
	m_pMediaAudioPlayer->SetVolume(audioRet.second);

#endif
}

void CLocalMediaPlayEntity::StartImage(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	if(eStand2sType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StartImage!");
			return;
		}

#ifdef RVC_OS_WIN
		if (0 == m_iPlayType){
			m_pImagePlayer[nCfgInx]->Play(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
		} 
		else{
			m_pPicturePlayer[nCfgInx]->Play(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
		}
#else
		m_pPicturePlayer[nCfgInx]->Play(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
#endif
		//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to StartImage!");
	}
}

void CLocalMediaPlayEntity::StopVideo(int nCfgInx)
{
	if(eStand2sType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopVideo!");
			return;
		}

		m_badplayflag = false;

#ifdef RVC_OS_WIN
		if (0 == m_iPlayType){
			if (NULL != m_playThread) {
				m_pVideoPlayer[nCfgInx]->Close();
				m_pImagePlayer[nCfgInx]->Close();
				WaitForSingleObject(m_playThread, INFINITE);
				m_playThread = NULL;
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StopVideo!");
			}
		} 
		else{
			if (NULL != m_uMediaPlayThreadId) {
				m_pMediaPlayer[nCfgInx]->Close();
				m_pPicturePlayer[nCfgInx]->Close();
				WaitForSingleObject(m_uMediaPlayThreadId, INFINITE);
				m_uMediaPlayThreadId = NULL;
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Succeed to StopVideo!");
			}
		}
#else
		if (0 != m_uMediaPlayThreadId) {
			m_pMediaPlayer[nCfgInx]->Close();
			m_pPicturePlayer[nCfgInx]->Close();
			pthread_join(m_uMediaPlayThreadId, NULL);
		}
#endif
	}
}

void CLocalMediaPlayEntity::StopAudio()
{
#ifdef RVC_OS_WIN
	if (0 == m_iPlayType){
		if (FALSE == m_pAudioPlayer->checkIsStop()) {
			m_pAudioPlayer->Close();
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to StopAudio!");
		}
	} 
	else{
		if(FALSE == m_pMediaAudioPlayer->checkIsStop())
			m_pMediaAudioPlayer->Close();
			m_buserstopaudio = true;
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to StopAudio!");
	}
#else
	if (false == m_pMediaAudioPlayer->checkIsStop()) {
		m_pMediaAudioPlayer->Close();
		m_buserstopaudio = true;
	}
#endif
}

void CLocalMediaPlayEntity::StopImage(int nCfgInx)
{
	if(eStand2sType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopImage!");
			return;
		}

#ifdef RVC_OS_WIN
		if (0 == m_iPlayType){
			if (FALSE == m_pImagePlayer[nCfgInx]->checkIsStop()) {
				m_pImagePlayer[nCfgInx]->Close();
				//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to StopImage!");
			}
		} 
		else{
			if (FALSE == m_pPicturePlayer[nCfgInx]->checkIsStop()) {
				m_pPicturePlayer[nCfgInx]->Close();
				//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to StopImage!");
			}
		}
#else
		if (false == m_pPicturePlayer[nCfgInx]->checkIsStop()) {
			m_pPicturePlayer[nCfgInx]->Close();
		}
#endif
	}
}

void CLocalMediaPlayEntity::StopAll()
{
	StopAudio(); // 关闭音频
	for (int i = 0; i < MAX_PLAY_CHANNELS; ++i){
		StopVideo(i); // 关闭视频
		StopImage(i); // 关闭图像
		StopNotice(i); // 关闭视频提示
	}
}

bool CLocalMediaPlayEntity::GetLocalVideoVolume(int nCfgInx, int &nVolume)
{
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get local video volume req.");
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->ReadConfigValueInt("LocalVideo", "Volume", nVolume);
		if (Error == Error_Succeed && nVolume >= 0 && nVolume <= 100)
		{
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to get local video volume!");

	return false;
}


std::pair<bool, int> CLocalMediaPlayEntity::GetLocalAudioVolume()
{
	CSmartPointer<IConfigInfo> spConfig;
	int nVolume = 0;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->ReadConfigValueInt("LocalAudio", "Volume", nVolume);
		if (nVolume == 0)
		{
			nVolume = 50;
			spConfig->WriteConfigValueInt("LocalAudio", "Volume", nVolume);
		}
		if (Error == Error_Succeed && nVolume >= 0 && nVolume <= 100)
		{
			return std::make_pair(true, nVolume);
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to get local audio volume!");
	return std::make_pair(false, nVolume);
}


bool CLocalMediaPlayEntity::SetLocalAudioVolume(int nVolume)
{
	if (nVolume < 0 || nVolume > 100){
		return false;
	}

	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->WriteConfigValueInt("LocalAudio", "Volume", nVolume);
		if (Error == Error_Succeed)
		{
#ifdef RVC_OS_WIN
			if (0 == m_iPlayType) {
				m_pAudioPlayer->SetVolume(nVolume);
		}
			else {
				m_pMediaAudioPlayer->SetVolume(nVolume);
			}
#else
			m_pMediaAudioPlayer->SetVolume(nVolume);
#endif
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to set local video volume!");

	return false;
}


bool CLocalMediaPlayEntity::SetLocalVideoVolume(int nCfgInx, int nVolume)
{
	if (nVolume < 0 || nVolume > 100){
		return false;
	}

	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed)
	{
		Error = spConfig->WriteConfigValueInt("LocalVideo", "Volume", nVolume);
		if (Error == Error_Succeed)
		{
			for (int i = 0; i < MAX_PLAY_CHANNELS; ++i)
			{
#ifdef RVC_OS_WIN
				if (0 == m_iPlayType){
					m_pVideoPlayer[i]->SetVolume(nVolume);
				} 
				else{
					m_pMediaPlayer[i]->SetVolume(nVolume);
				}
#else
				m_pMediaPlayer[i]->SetVolume(nVolume);
#endif
			}
			return true;
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fail to set local video volume!");

	return false;
}


bool CLocalMediaPlayEntity::IsRunConfigExist()
{
	CSimpleStringA strPath;
	ErrorCodeEnum eErr;

	if ((eErr = GetFunction()->GetPath("RunInfo", strPath)) != Error_Succeed){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get runinfo path failed(%d)", eErr);
		return false;
	}

#ifdef RVC_OS_WIN
	CSimpleStringA strRuninfoFile;
	strRuninfoFile = CSimpleStringA::Format("%s\\runcfg\\%s.ini", (LPCTSTR)strPath, GetEntityName());
	WIN32_FIND_DATA  findData;
	if (FindFirstFileA((LPCTSTR)strRuninfoFile, &findData) != INVALID_HANDLE_VALUE) return true;
	return false;
#else
	CSimpleStringA strRuninfoFile;
	strRuninfoFile = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "%s.ini", (LPCTSTR)strPath, GetEntityName());
	if (ExistsFileA(strRuninfoFile)) {
		return true;
	}
	else {
		return false;
	}
#endif
}


ErrorCodeEnum CLocalMediaPlayEntity::StartMediaPlayerNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName)
{
	m_mediaParam.nCfgInx = nCfgInx;

	CSimpleStringA strPath;
	ErrorCodeEnum Error = GetFunction()->GetPath("ADData", strPath);
	if (Error == Error_Succeed) {
#ifdef RVC_OS_WIN
		CSimpleStringA VideoPath = strPath + "\\Video\\";
		CSimpleStringA strNoticeFileName = VideoPath + pVideoName;
		if(ExistsFileA(strNoticeFileName.GetData())){
			static HANDLE noticePlayThread = NULL;

			if (noticePlayThread)
			{
				DWORD exitCode = 0;
				if (WAIT_TIMEOUT == WaitForSingleObject(noticePlayThread, 800))
				{
					m_pVideoPlayer[nCfgInx]->Close();
				}
				noticePlayThread = NULL;
			}

			if (m_pMediaPlayer[nCfgInx]->IsFileValid(strNoticeFileName.GetData())){
				//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_pVideoPlayer[%d] = 0x%08x while play!",nCfgInx, m_pVideoPlayer[nCfgInx]);
				m_pVideoPlayer[nCfgInx]->PlayVideoNotice(nWndX, nWndY, nWndWidth, nWndHeight, VideoPath.GetData(), pVideoName);;

				int iVolume = 60;
				GetLocalVideoVolume(nCfgInx,iVolume);
				m_pVideoPlayer[nCfgInx]->SetVolume(iVolume);
				m_lastPlayVideo = pVideoName;

				noticePlayThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&NoticePlayThread, this, 0, NULL);
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_START_NOTICE_PLAY, CSimpleStringA::Format("start play notice %s", strNoticeFileName.GetData()).GetData());
			}
			else{
				Error = Error_InvalidState;
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_FILE_NOT_VALID, CSimpleStringA::Format("play notice failed for %s is not valid!", strNoticeFileName.GetData()).GetData());
			}
		}
		else{
			Error = Error_InvalidState;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_FILE_NOT_EXIST, CSimpleStringA::Format("play notice failed for %s not exist!", strNoticeFileName.GetData()).GetData());
		}
#endif
	}

	return Error;
}


#ifdef RVC_OS_WIN
DWORD WINAPI StartNoticePlayThreadFunc(LPVOID param)
{
	int iRet = -1;
	CLocalMediaPlayEntity* entity = (CLocalMediaPlayEntity*)param;
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter NoticePlayThreadFunc and process id is %u, thread id is %u.", GetCurrentProcessId(), GetCurrentThreadId());
	const char* pVideoName = entity->m_lastPlayVideo.c_str();
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Begin Start Notice Play, and Video Notice Info is %s.", pVideoName);

	Clibmediaplayer* player = entity->m_pMediaPlayer[entity->m_mediaParam.nCfgInx];
	player->PlayVideoNotice(entity->m_mediaParam.nWndX, entity->m_mediaParam.nWndY, entity->m_mediaParam.nWndWidth, entity->m_mediaParam.nWndHeight, pVideoName);

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Succeed to Start Notice Play, and Video Notice Info is %s.", pVideoName);
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Leave NoticePlayThreadFunc");
	entity->m_uNoticePlayThreadId = NULL;

	iRet = 0;

	return iRet;
}
#endif

ErrorCodeEnum CLocalMediaPlayEntity::StartFFPlayerNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName)
{
	ErrorCodeEnum Error = Error_Succeed;

	if (m_pMediaAudioPlayer->checkIsPlay()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio current is playing, close it.");
		if (0 != m_uMediaPlayThreadId) {
			m_pMediaAudioPlayer->Close();
#ifdef RVC_OS_WIN
			WaitForSingleObject(m_uMediaPlayThreadId, INFINITE);
#else
			pthread_join(m_uMediaPlayThreadId, NULL);
#endif // RVC_OS_WI
		}
	}

	if (m_pMediaPlayer[nCfgInx]->checkIsPlay()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("video current is playing, close it.");
		if (NULL != m_uNoticePlayThreadId) {
			m_pMediaPlayer[nCfgInx]->Close();
#ifdef RVC_OS_WIN
			WaitForSingleObject(m_uNoticePlayThreadId, INFINITE);
#else
			pthread_join(m_uNoticePlayThreadId, NULL);
#endif // RVC_OS_WI
		}
	}

	m_mediaParam.nCfgInx = nCfgInx;
	m_mediaParam.nWndX = 1280;
	m_mediaParam.nWndY = 0;
	m_mediaParam.nWndWidth = nWndWidth;
	m_mediaParam.nWndHeight = nWndHeight;

	CSimpleStringA strPath;
	Error = GetFunction()->GetPath("ADData", strPath);
	if (Error == Error_Succeed) {
		CSimpleStringA VideoPath = strPath + "/Video/";
		CSimpleStringA strNoticeFileName = VideoPath + CSimpleStringA(pVideoName);

		BOOL bRet = ExistsFile(strNoticeFileName.GetData());
		if (bRet) {
			if (m_pMediaPlayer[nCfgInx]->IsFileValid(strNoticeFileName.GetData())){
				int iVolume = 60;
				GetLocalVideoVolume(nCfgInx, iVolume);
				m_pMediaPlayer[nCfgInx]->SetVolume(iVolume);
				m_lastPlayVideo = strNoticeFileName.GetData();
#ifdef RVC_OS_WIN
				m_uNoticePlayThreadId = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&StartNoticePlayThreadFunc, this, 0, NULL);
				if (NULL != m_uNoticePlayThreadId) {
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_START_NOTICE_PLAY, CSimpleStringA::Format("start play video notice %s", strNoticeFileName.GetData()).GetData());
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create notice play thread failed.");
				}
#else
				int err = pthread_create(&m_uNoticePlayThreadId, NULL, StartNoticePlayThreadFunc, this);
				if (0 == err) {
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_START_NOTICE_PLAY, CSimpleStringA::Format("start play video notice %s", strNoticeFileName.GetData()).GetData());
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create notice play thread failed.");
				}
#endif
			}
			else{
				Error = Error_InvalidState;
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_FILE_NOT_VALID, CSimpleStringA::Format("play notice failed for %s is not valid!", strNoticeFileName.GetData()).GetData());
			}
		}
		else {
			Error = Error_InvalidState;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_NOTICE_FILE_NOT_EXIST, CSimpleStringA::Format("play notice failed for %s not exist!", strNoticeFileName.GetData()).GetData());
		}
	}

	return Error;
}


ErrorCodeEnum CLocalMediaPlayEntity::StartNotice(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char *pVideoName)
{
	ErrorCodeEnum Error = Error_Succeed;
	if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0 || NULL == pVideoName)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid param CfgInx or video name while StartNotice!");
			return Error_Param;
		}

		if (0 == m_iPlayType){
			Error = StartMediaPlayerNotice(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight, pVideoName);
		} 
		else{
			Error = StartFFPlayerNotice(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight, pVideoName);
		}
	}

	return Error;
}


ErrorCodeEnum CLocalMediaPlayEntity::StopNotice(int nCfgInx)
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType){
		if (nCfgInx >= MAX_PLAY_CHANNELS || nCfgInx < 0){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid CfgInx while StopNotice!");
			return Error_Param;
		}
#ifdef RVC_OS_WIN
		if (0 == m_iPlayType){
			//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_pPlayer = 0x%08x while play!", m_pVideoPlayer[nCfgInx]);
			if (FALSE == m_pVideoPlayer[nCfgInx]->checkIsStop()) {
				m_pVideoPlayer[nCfgInx]->Close();
				if (m_lastPlayVideo.length() > 0) {
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_STOP_NOTICE_PLAY, CSimpleStringA::Format("success to stop play notice ", m_lastPlayVideo.c_str()).GetData());
				}
			}
		} 
		else{
			if (FALSE == m_pMediaPlayer[nCfgInx]->checkIsStop()) {
				m_pMediaPlayer[nCfgInx]->Close();
				if (NULL != m_uNoticePlayThreadId) {
					WaitForSingleObject(m_uNoticePlayThreadId, INFINITE);
					if (m_lastPlayVideo.length() > 0) {
						LogWarn(Severity_Low, Error_Debug, LOG_EVT_STOP_NOTICE_PLAY, CSimpleStringA::Format("success to stop play notice ", m_lastPlayVideo.c_str()).GetData());
					}
					m_uNoticePlayThreadId = NULL;
				}
			}
		}
#else
		m_pMediaPlayer[nCfgInx]->Close();

		if (m_uNoticePlayThreadId > 0) {
			if (0 == pthread_join(m_uNoticePlayThreadId, NULL)) {
				if (m_lastPlayVideo.length() > 0) {
					LogWarn(Severity_Low, Error_Debug, LOG_EVT_STOP_NOTICE_PLAY, CSimpleStringA::Format("%s%s", "success to stop play notice ", m_lastPlayVideo.c_str()).GetData());
				}
			}
			m_uNoticePlayThreadId = 0;
		}
#endif
	}

	return ErrorCode;
}


ErrorCodeEnum CLocalMediaPlayEntity::StopPlayAllMedias()
{
	ErrorCodeEnum ErrorCode = Error_Succeed;

	StopAll();

	return ErrorCode;
}


void CLocalMediaPlayEntity::SetLogFlag(bool bflag)
{
	m_bLogFlag = bflag;
}


bool CLocalMediaPlayEntity::GetLogFlag()
{
	return m_bLogFlag;
}


void CLocalMediaPlayEntity::SetLocalLogFlag(bool bflag)
{
	m_bLocalLogFlag = bflag;
}


bool CLocalMediaPlayEntity::GetLocalLogFlag()
{
	return m_bLocalLogFlag;
}


void CLocalMediaPlayEntity::SetLocalPicLogFlag(bool bflag)
{
	m_bLocalPicLogFlag = bflag;
}


bool CLocalMediaPlayEntity::GetLocalPicLogFlag()
{
	return m_bLocalPicLogFlag;
}

void CLocalMediaPlayEntity::OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	if (Test_ShakeHand == eTestType){
		pTransactionContext->SendAnswer(Error_Succeed);
	}
}


void CLocalMediaPlaySession::Handle_StartPlayVideo(SpReqAnsContext<PlayService_StartPlayVideo_Req, PlayService_StartPlayVideo_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("start play Video, Index:%d, WndX:%d, WndY:%d, WndWidth:%d, WndWidth:%d", ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	
	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}
	
	if (eStand2sType == m_pEntity->GetDeviceType()){
		m_pEntity->StartVideo(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	}
	
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StartPlayAudio(SpReqAnsContext<PlayService_StartPlayAudio_Req, PlayService_StartPlayAudio_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	CSimpleStringA AudioNames = CSimpleStringW2A(ctx->Req.AudioNames);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("start play audio, name:%s", AudioNames.GetData());

	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}

	m_pEntity->StartAudio(AudioNames.GetData());
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StartPlayImage(SpReqAnsContext<PlayService_StartPlayImage_Req, PlayService_StartPlayImage_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->StartImage(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayVideo(SpReqAnsContext<PlayService_StopPlayVideo_Req, PlayService_StopPlayVideo_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop play Video, Index:%d", ctx->Req.CfgInx);
	m_pEntity->StopVideo(ctx->Req.CfgInx);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayAudio(SpReqAnsContext<PlayService_StopPlayAudio_Req, PlayService_StopPlayAudio_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->StopAudio();
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::Handle_StopPlayImage(SpReqAnsContext<PlayService_StopPlayImage_Req, PlayService_StopPlayImage_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->StopImage(ctx->Req.CfgInx);
	ctx->Answer(Error_Succeed);
}

void CLocalMediaPlaySession::OnClose(ErrorCodeEnum)
{

}

void CLocalMediaPlaySession::Handle_GetLocalVideoVolume( SpReqAnsContext<PlayService_GetLocalVideoVolume_Req, PlayService_GetLocalVideoVolume_Ans>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int volume = 0;
	if (m_pEntity->GetLocalVideoVolume(ctx->Req.CfgInx, volume)){
		ctx->Ans.Volume = volume;
		ctx->Answer(Error_Succeed);
	}
	else{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_SetLocalVideoVolume( SpReqAnsContext<PlayService_SetLocalVideoVolume_Req, PlayService_SetLocalVideoVolume_Ans>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (m_pEntity->SetLocalVideoVolume(ctx->Req.CfgInx, ctx->Req.Volume)){
		ctx->Answer(Error_Succeed);
	}
	else{
		ctx->Answer(Error_Unexpect);
	}
}


void CLocalMediaPlaySession::Handle_GetLocalAudioVolume(SpReqAnsContext<PlayService_GetLocalAudioVolume_Req, PlayService_GetLocalAudioVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto audioRet = m_pEntity->GetLocalAudioVolume();
	if (audioRet.first){
		ctx->Ans.Volume = audioRet.second;
		ctx->Answer(Error_Succeed);
	}
	else{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_SetLocalAudioVolume(SpReqAnsContext<PlayService_SetLocalAudioVolume_Req, PlayService_SetLocalAudioVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (m_pEntity->SetLocalAudioVolume(ctx->Req.Volume)){
		ctx->Answer(Error_Succeed);
	}
	else{
		ctx->Answer(Error_Unexpect);
	}
}

void CLocalMediaPlaySession::Handle_StartPlayNotice(SpReqAnsContext<PlayService_StartPlayNotice_Req, PlayService_StartPlayNotice_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	CSimpleStringA UpdateState = "";
	ErrorCodeEnum Error = m_pEntity->GetFunction()->GetSysVar("UpdateState", UpdateState);
	if (Error == Error_Succeed && "1" == UpdateState){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("detect current is upgrade, do not play the media");
		ctx->Answer(Error_Stoped);
		m_pEntity->StopAll();
		return;
	}

	CSimpleStringA VideoName = CSimpleStringW2A(ctx->Req.VideoName);
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start play notice, CfgInx = %d, WndX = %d, WndY = %d, WndWidth = %d, WndHeight = %d, and video name is %s.", ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight, VideoName.GetData());
	Error = m_pEntity->StartNotice(ctx->Req.CfgInx, ctx->Req.WndX, ctx->Req.WndY, ctx->Req.WndWidth, ctx->Req.WndHeight, VideoName.GetData());
	ctx->Answer(Error);
}

void CLocalMediaPlaySession::Handle_StopPlayNotice(SpReqAnsContext<PlayService_StopPlayNotice_Req, PlayService_StopPlayNotice_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("stop play notice, Index:%d", ctx->Req.CfgInx);
	ErrorCodeEnum Error = m_pEntity->StopNotice(ctx->Req.CfgInx);
	ctx->Answer(Error);
}


void CLocalMediaPlaySession::Handle_StopPlayAllMedias(SpReqAnsContext<PlayService_StopPlayAllMedias_Req, PlayService_StopPlayAllMedias_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("stop play all medias");
	ErrorCodeEnum Error = m_pEntity->StopPlayAllMedias();
	ctx->Answer(Error);
}


SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CLocalMediaPlayEntity)
SP_END_ENTITY_MAP()