myvtm/Other/libmediaplayer/libmediaplayer.cpp

#include "libmediaplayer.h"
#include "player.h"
#include <unistd.h>


class libmediaplayer_impl
{
private:
	CMediaHostApi* m_pHostApi;
	CMediaPlayer* m_Player;
	CMediaPlayConfig m_stPlayConfig;
	bool m_bisplaying;

public:

	libmediaplayer_impl(CMediaHostApi* pHostApi) {
		m_pHostApi = pHostApi;

		m_Player = new CMediaPlayer(pHostApi);
		if (NULL == m_Player) {
			pHostApi->Debug(MEDIA_LOG_DEBUG, "new MediaPlayer failed!");
		}
		memset(&m_stPlayConfig, 0, sizeof(CMediaPlayConfig));
		m_bisplaying = false;
	}

	~libmediaplayer_impl()
	{
		m_pHostApi = NULL;
		delete m_Player;
		m_Player = NULL;
		m_bisplaying = false;
	}

	bool isStop() { return !m_bisplaying; }

	static void __cb_play_finished(void* user_data)
	{
		libmediaplayer_impl* pthis = static_cast<libmediaplayer_impl*>(user_data);
		if (NULL != pthis){
			pthis->PlayMediaFinished();
			pthis->m_bisplaying = false;
		}
	}

	int StartPlayVideo(const char* pVideoDir, const char* pNamePrefix = NULL, int nVideoCount = 1)
	{
		int iRet = -1;
		if (NULL == pVideoDir || NULL == pNamePrefix){
			return iRet;
		}

		play_media_callback_t cb;
		cb.cb_play_media_finished = &__cb_play_finished;
		cb.user_data = this;

		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "audio root path is %s.", pVideoDir);
		char strVideoName[MAX_PATH] = { 0 };
		snprintf(strVideoName, MAX_PATH, "%s/%s", pVideoDir, pNamePrefix);
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "video full path is %s.", strVideoName);
		if (!IsFileExist(strVideoName)) {
			return iRet;
		}

		rvc_media_player_param_t t_param = { 0 };
		t_param.p_input_file = strVideoName;
		t_param.cb = &cb;
		t_param.eType = eVideo_Type;
		t_param.eWindType = eVideoSize_Type;
		t_param.idisplaycx = SDL_WINDOWPOS_UNDEFINED;
		t_param.idisplaycy = SDL_WINDOWPOS_UNDEFINED;

		memcpy(t_param.strPlayLists[0], strVideoName, strlen(strVideoName));
		t_param.uFilesCount = 1;

		if (0 == m_Player->InitParam(&t_param)){
			m_bisplaying = true;
			iRet = m_Player->StartMediaPlay();
		}

		return iRet;
	}

	int GetLocalAudioPlayingParams(rvc_media_player_param_t* pParam, const char* pAudioNames)
	{
		int iRet = -1;
		if (NULL == pParam || NULL == pAudioNames) {
			return iRet;
		}
		
		pParam->eType = eAudio_Type;
		pParam->eWindType = eVideoSize_Type;

		// 切分音频文件名
		size_t uLen = strlen(pAudioNames);
		char* Tmp = new char[uLen + 1];
		memset(Tmp, 0, uLen + 1);
		memcpy(Tmp, pAudioNames, uLen);

		char* Result[MAX_FILECOUNT] = { NULL };
		CStringSplit(Tmp, Result, "|");
		int FileCount = 0;
		char** pStr = Result;
		while (*pStr != NULL) {
			++pStr; 
			++FileCount;
		}
		m_stPlayConfig.bPrimMonitor = true;
		m_stPlayConfig.nFileCnt = FileCount;
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "wmp pAudioNames = %s!", pAudioNames);
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "wmp config.nFileCnt = %d!", FileCount);
		size_t uValidCount = 0;
		for (int i = 0; i < FileCount && i < MAX_FILECOUNT; i++) {
			char strFileName[MAX_PATH] = { 0 };
			snprintf(strFileName, MAX_PATH, "%s%s", m_stPlayConfig.strRootPath, Result[i]);
			if (IsFileExist(strFileName)) {
				memcpy(pParam->strPlayLists[i], strFileName, strlen(strFileName));
				uValidCount++;
			}
			else {
				m_pHostApi->Debug(MEDIA_LOG_DEBUG, "File %s is not exist.", strFileName);
				continue;
			}
		}
		delete[] Tmp;
		Tmp = NULL;

		pParam->uFilesCount = uValidCount;
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "pParam uFilesCount = %d", pParam->uFilesCount);
		if (uValidCount > 0) {
			iRet = 0;
		}
		
		return iRet;
	}

	int StartPlayLocalAudio(const char* pAudioNames)
	{
		int iRet = -1;
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "StartPlayLocalAudio %s.", pAudioNames);

		m_stPlayConfig.eMode = LOCALAUDIO;
		iRet = m_pHostApi->LoadPlayConfig(m_stPlayConfig);
		m_stPlayConfig.eMode = LOCALAUDIO;
		if (0 != iRet){
			m_pHostApi->Debug(MEDIA_LOG_ERROR, "Load WmpConfiguration failed while play local audio!");
			return iRet;
		}
		else{
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Load WmpConfiguration succeeded while play local audio!");
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "m_stPlayConfig.strRootPath: %s", m_stPlayConfig.strRootPath);
		}

		rvc_media_player_param_t t_param = { 0 };
		if (0 != GetLocalAudioPlayingParams(&t_param, pAudioNames)){
			return iRet;
		}

		play_media_callback_t cb;
		cb.cb_play_media_finished = &__cb_play_finished;
		cb.user_data = this;
		t_param.cb = &cb;

		if (0 == m_Player->InitParam(&t_param)){
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Player Init success!");
			m_bisplaying = true;
			iRet = m_Player->StartMediaPlay();
		}
		else{
			m_pHostApi->Debug(MEDIA_LOG_ERROR, "Player Init failed!");
		}
		return iRet;
	}


	int GetLocalVideoPlayingParams(rvc_media_player_param_t* pParam)
	{
		int iRet = -1;
		if (NULL == pParam) {
			return iRet;
		}

		pParam->eType = eVideo_Type;
		pParam->eWindType = eFullScreen_Type;
		size_t uValidCount = 0;
		for (int i = 0; i < m_stPlayConfig.nFileCnt && i < MAX_FILECOUNT; i++) {
			char strFileName[MAX_PATH] = { 0 };
			snprintf(strFileName, MAX_PATH, "%s%s", m_stPlayConfig.strRootPath, m_stPlayConfig.strFileNames[i]);
			if (IsFileExist(strFileName)) {
				memcpy(pParam->strPlayLists[i], strFileName, strlen(strFileName));
				uValidCount++;
			}
			else {
				m_pHostApi->Debug(MEDIA_LOG_DEBUG, "File %s is not exist.", strFileName);
				continue;
			}
		}
		pParam->uFilesCount = uValidCount;
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "pParam uFilesCount = %d", pParam->uFilesCount);
		if (uValidCount > 0){
			iRet = 0;
		}

		return iRet;
	}


	int StartPlayLocalVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
	{
		int iRet = -1;
		m_stPlayConfig.eMode = LOCALVIDEO;
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "nCfgInx=%d, nWndX=%d, nWndY=%d, nWndWidth=%d, nWndHeight=%d!", nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
		iRet = m_pHostApi->LoadPlayConfig(m_stPlayConfig, nCfgInx);
		m_stPlayConfig.eMode = LOCALVIDEO;
		m_stPlayConfig.nWndX = nWndX;
		m_stPlayConfig.nWndY = nWndY;
		m_stPlayConfig.nWndWidth = nWndWidth;
		m_stPlayConfig.nWndHeight = nWndHeight;
		if (0 != iRet){
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Load WmpConfiguration failed while play local video!");
			return iRet;
		}
		else{
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Load WmpConfiguration succeeded while play local video!");
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "m_stPlayConfig.strRootPath: %s,m_stPlayConfig.nFileCnt:%d", m_stPlayConfig.strRootPath, m_stPlayConfig.nFileCnt);
		}

		// 判断当前时间是否允许播放
		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, m_stPlayConfig.strVideoRunTime_S) < 0 || strcmp(strNow, m_stPlayConfig.strVideoRunTime_E) >= 0)
		{
			//m_pHostApi->Debug("Now is %s, video play start time is %s, video play stop time is %s, play video rejected!", strNow, m_stPlayConfig.strVideoRunTime_S, m_stPlayConfig.strVideoRunTime_E);
			iRet = 0;
			return iRet;
		}

		rvc_media_player_param_t t_param = {0};
		if (0 != GetLocalVideoPlayingParams(&t_param)) {
			return iRet;
		}

		t_param.idisplaycx = SDL_WINDOWPOS_UNDEFINED;
		t_param.idisplaycy = SDL_WINDOWPOS_UNDEFINED;
		t_param.bvicemonitor = true;

		play_media_callback_t cb;
		cb.cb_play_media_finished = &__cb_play_finished;
		cb.user_data = this;
		t_param.cb = &cb;

		if (0 == m_Player->InitParam(&t_param)){
			m_bisplaying = true;
			iRet = m_Player->StartMediaPlay();
		}
		else{
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "player init failed!");
		}

		return iRet;
	}


	bool checkIsPlay()
	{
		return m_bisplaying;
	}

	bool checkIsStop()
	{
		return !m_bisplaying;
	}

	int StartPlayMedia(CMediaPlayConfig& config)
	{
		int iRet = -1;
		memcpy(&m_stPlayConfig, &config, sizeof(CMediaPlayConfig));
		// 判断当前时间是否允许播放
		struct tm* ptm = NULL;
		time_t t = time(NULL);
		ptm = localtime(&t);
		char strNow[TIME_LEN] = { 0 };
		snprintf(strNow, TIME_LEN, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
		if (strcmp(strNow, m_stPlayConfig.strVideoRunTime_S) < 0 || strcmp(strNow, m_stPlayConfig.strVideoRunTime_E) >= 0)
		{
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Now is %s, video play start time is %s, video play stop time is %s, play video rejected!", strNow, m_stPlayConfig.strVideoRunTime_S, m_stPlayConfig.strVideoRunTime_E);
			iRet = -2;
			return iRet;
		}

		rvc_media_player_param_t t_param = { 0 };
		//if (0 != GetLocalVideoPlayingParams(&t_param)) {
		//	return iRet;
		//}
		t_param.eType = eVideo_Type;
		t_param.eWindType = eFullScreen_Type;
		t_param.bvicemonitor = true;

		char strFileName[MAX_PATH] = { 0 };
		snprintf(strFileName, MAX_PATH, "%s%s", m_stPlayConfig.strRootPath, m_stPlayConfig.strFileNames[0]);
		if (IsFileExist(strFileName)) {
			memcpy(t_param.strPlayLists[0], strFileName, strlen(strFileName));
			t_param.uFilesCount = 1;
		}
		else {
			m_pHostApi->Debug(MEDIA_LOG_DEBUG,"File %s is not exist.", strFileName);
			t_param.uFilesCount = 0;
			return iRet;
		}
		
		m_pHostApi->Debug(MEDIA_LOG_DEBUG,"pParam uFilesCount = %d", t_param.uFilesCount);

		play_media_callback_t cb;
		cb.cb_play_media_finished = &__cb_play_finished;
		cb.user_data = this;
		t_param.cb = &cb;

		m_Player->SetVolume(config.nVolume);
		if (0 == m_Player->InitParam(&t_param)) {
			m_bisplaying = true;
			iRet = m_Player->StartMediaPlay();
		}
		else {
			m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Player Init failed!");
		}
		return iRet;
	}

	bool StopPlay()
	{
		if (m_Player->GetPlayingFlag())
		{
			m_Player->StopMediaPlay();
		}
		
		return true;
	}

	void SetVolume(int nVolume)
	{
		//if (m_Player->GetPlayingFlag())
		{
			m_Player->SetVolume(nVolume);
		}
	}

	void StartPlaySalesRecordVideo(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pVideoDir, const char* pNamePrefix = NULL, int nVideoCount = 1)
	{

	}

	void PlayMediaFinished() 
	{
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "PlayMediaFinished!");
		m_pHostApi->AudioPlayFinished();
	}

	CMediaHostApi* GetHostApi()
	{
		return m_pHostApi;
	}

	bool IsFileExist(const char* pFilePath)
	{
		bool bRet = false;
		if (NULL != pFilePath){
			if (0 == access(pFilePath, F_OK)) {
				bRet = true;
			}
		}
		return bRet;
	}

	// 按分隔符分隔字符串
	void CStringSplit(char* str, char** result, const char* del)
	{
		char* p = strtok(str, del);
		while (p != NULL)
		{
			*result++ = p;
			p = strtok(NULL, del);
		}
	}
};


Clibmediaplayer::Clibmediaplayer(CMediaHostApi* pHostApi)
{
	m_pImpl = new libmediaplayer_impl(pHostApi);
	return;
}

Clibmediaplayer::~Clibmediaplayer()
{
	delete m_pImpl;
	m_pImpl = NULL;
}

int Clibmediaplayer::PlayVideo(const char* pVideoDir, const char* pNamePrefix, int nVideoCount)
{
	return m_pImpl->StartPlayVideo(pVideoDir, pNamePrefix, nVideoCount);
}

int Clibmediaplayer::PlayLocalAudio(const char* pAudioNames)
{
	m_pImpl->GetHostApi()->Debug(MEDIA_LOG_DEBUG, "Clibmediaplayer StartPlayLocalAudio");
	return m_pImpl->StartPlayLocalAudio(pAudioNames);
}

int Clibmediaplayer::PlayLocalVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	return m_pImpl->StartPlayLocalVideo(nCfgInx, nWndX, nWndY, nWndWidth, nWndHeight);
}

bool Clibmediaplayer::checkIsPlay()
{
	return m_pImpl->checkIsPlay();
}

bool Clibmediaplayer::checkIsStop()
{
	return m_pImpl->isStop();
}

int Clibmediaplayer::PlayMedia(CMediaPlayConfig& config)
{
	return m_pImpl->StartPlayMedia(config);
}

void Clibmediaplayer::Close()
{
	m_pImpl->StopPlay();
}

void Clibmediaplayer::SetVolume(int nVolume)
{
	m_pImpl->SetVolume(nVolume);
}

void Clibmediaplayer::PlaySalesRecordVideo(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pVideoDir, const char* pNamePrefix, int nVideoCount)
{
	m_pImpl->StartPlaySalesRecordVideo(nWndX, nWndY, nWndWidth, nWndHeight, pVideoDir, pNamePrefix, nVideoCount);
}

int mediaplayer_init()
{
	avcodec_register_all();
	return 0;
}

int mediaplayer_term()
{
	return 0;
}