myvtm/Other/win/libmediaplayer/libmediaplayer.cpp

#include "libmediaplayer.h"
#include "player.h"
#include <stdlib.h>
#include <string.h>
#include <io.h>

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

public:
	libmediaplayer_impl(CMediaHostApi* pHostApi);
	~libmediaplayer_impl();

	bool isStop();
	void PlayMediaFinished();
	int StartPlayVideo(const char* pVideoDir, const char* pNamePrefix = NULL, int nVideoCount = 1);
	int GetLocalAudioPlayingParams(rvc_media_player_param_t* pParam, const char* pAudioNames);
	int StartPlayLocalAudio(const char* pAudioNames);
	int GetLocalVideoPlayingParams(rvc_media_player_param_t* pParam);
	int StartPlayLocalVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight);
	int StartPlayMedia(CMediaPlayConfig& config);
	bool StopPlay();
	void SetVolume(int nVolume);
	void StartPlaySalesRecordVideo(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pVideoDir, const char* pNamePrefix = NULL, int nVideoCount = 1);
	void StartPlayVideoNotice(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pFileName);
	bool checkIsPlay();
	bool checkIsStop();
	CMediaHostApi* GetHostApi();
	int PlayingAudioPcmCallback(audio_param_t* param, const void* input, unsigned long uaudiolen);
	bool IsFileValid(const char* pVideoName);
};


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


void CStringSplit(char* str, char** result, const char* del)
{
	char* ptr = NULL;
	char* p = strtok_s(str, del, &ptr);
	while (p != NULL)
	{
		*result++ = p;
		p = strtok_s(NULL, del, &ptr);
	}
}


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;
	}
}


static int __cb_playing_audio_data(audio_param_t* param, const void* input, unsigned long uaudiolen, void* user_data)
{
	int iret = -1;
	libmediaplayer_impl* pthis = static_cast<libmediaplayer_impl*>(user_data);
	if (NULL != pthis) {
		iret = pthis->PlayingAudioPcmCallback(param, input, uaudiolen);
	}

	return iret;
}


libmediaplayer_impl::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::~libmediaplayer_impl()
{
	m_pHostApi = NULL;
	delete m_Player;
	m_Player = NULL;
	m_bisplaying = false;
}


bool libmediaplayer_impl::isStop() 
{
	return !m_bisplaying; 
}


void libmediaplayer_impl::PlayMediaFinished()
{
	m_pHostApi->Debug(MEDIA_LOG_DEBUG, "PlayMediaFinished!");
	m_pHostApi->MediaPlayFinished(m_Player->GetPlayingMediaType());
}


int libmediaplayer_impl::PlayingAudioPcmCallback(audio_param_t* param, const void* input, unsigned long uaudiolen)
{
	return m_pHostApi->PlayingAudioDataCallback(param, input, uaudiolen);
}


bool libmediaplayer_impl::IsFileValid(const char* pVideoName)
{
	bool bret= false;
	int err = -1;

	AVFormatContext* p_fmt_ctx = avformat_alloc_context();
	if (!p_fmt_ctx){
		return bret;
	}
	
	// 1. 构建AVFormatContext
	// 1.1 打开视频文件：读取文件头，将文件格式信息存储在"fmt context"中
	err = avformat_open_input(&p_fmt_ctx, pVideoName, NULL, NULL);
	if (0 == err){
		err = avformat_find_stream_info(p_fmt_ctx, NULL);
		if (err >= 0){
			for (int i = 0; i < (int)p_fmt_ctx->nb_streams; i++){
				if ((p_fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) || AVMEDIA_TYPE_VIDEO == p_fmt_ctx->streams[i]->codecpar->codec_type){
					bret = true;
				}
			}
		}
	}

	avformat_close_input(&p_fmt_ctx);
	avformat_free_context(p_fmt_ctx);

	return bret;
}


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

	play_media_callback_t cb = {0};
	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 libmediaplayer_impl::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 libmediaplayer_impl::StartPlayLocalAudio(const char* pAudioNames)
{
	int iRet = -1;
	m_pHostApi->Debug(MEDIA_LOG_DEBUG, "StartPlayLocalAudio %s.", pAudioNames);

	m_stPlayConfig.eMode = MEDIA_LOCALAUDIO;
	iRet = m_pHostApi->LoadPlayConfig(m_stPlayConfig);
	m_stPlayConfig.eMode = MEDIA_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 = { 0 };
	cb.cb_play_media_finished = &__cb_play_finished;
	cb.cb_playing_audiodata = &__cb_playing_audio_data;
	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 libmediaplayer_impl::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 libmediaplayer_impl::StartPlayLocalVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight)
{
	int iRet = -1;
	m_stPlayConfig.eMode = MEDIA_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 = MEDIA_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 = { 0 };
	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;
}


int libmediaplayer_impl::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 = { 0 };
	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 libmediaplayer_impl::StopPlay()
{
	if (m_Player->GetPlayingFlag())
	{
		m_Player->StopMediaPlay();
	}

	return true;
}

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

void libmediaplayer_impl::StartPlaySalesRecordVideo(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pVideoDir, const char* pNamePrefix, int nVideoCount)
{

}

void libmediaplayer_impl::StartPlayVideoNotice(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pFileName)
{
	int iRet = -1;
	if (NULL == pFileName) {
		return;
	}

	rvc_media_player_param_t t_param = { 0 };
	t_param.uFilesCount = 1;
	t_param.eType = eVideo_Type;
	t_param.eWindType = eSpecified_Type;
	t_param.idisplaycx = nWndX;
	t_param.idisplaycy = nWndY;
	t_param.idisplaywidth = nWndWidth;
	t_param.idisplayheight = nWndHeight;
	t_param.bvicemonitor = false;
	memcpy(&t_param.strPlayLists[0], pFileName, strlen(pFileName));

	play_media_callback_t cb = { 0 };
	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;
}


bool libmediaplayer_impl::checkIsPlay()
{
	return m_bisplaying;
}

bool libmediaplayer_impl::checkIsStop()
{
	return !m_bisplaying;
}

CMediaHostApi* libmediaplayer_impl::GetHostApi() 
{ 
	return m_pHostApi; 
}

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);
}

void Clibmediaplayer::PlayVideoNotice(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pFileName)
{
	m_pImpl->StartPlayVideoNotice(nWndX, nWndY, nWndWidth, nWndHeight, pFileName);
}


bool Clibmediaplayer::IsFileValid(const char* pVideoName)
{
	return m_pImpl->IsFileValid(pVideoName);
}

int mediaplayer_init()
{
	return 0;
}

int mediaplayer_term()
{
	return 0;
}