myvtm/Other/libmediaplayer/libmediaplayer.cpp

#include "libmediaplayer.h"
#include "player.h"
#ifdef _WIN32
#include <stdlib.h>
#include <string.h>
#include <io.h>
#else
#include <unistd.h>
#endif


#ifndef RVC_DEFAULT_VIDEO_WIDTH
#define RVC_DEFAULT_VIDEO_WIDTH 1920
#endif // !RVC_DEFAULT_VIDEO_WIDTH

#ifndef RVC_DEFAULT_VIDEO_HEIGHT
#define RVC_DEFAULT_VIDEO_HEIGHT 1080
#endif // !RVC_DEFAULT_VIDEO_HEIGHT

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 GetLocalAudioPlayingParams(rvc_media_player_param_t* pParam, const char* pAudioNames);
	int StartPlayLocalAudio(const char* pAudioNames);
	int StartPlayMedia(CMediaPlayConfig& config);
	bool StopPlay();
	void SetVolume(int nVolume);
	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) {
#ifdef _WIN32
		if (0 == _access(pFilePath, 0)) {
			bRet = true;
	}
#else
		if (0 == access(pFilePath, 0)) {
			bRet = true;
		}
#endif // _WIN32
	}
	return bRet;
}


void CStringSplit(char* str, char** result, const char* del)
{
	char* ptr = NULL;
#ifdef _WIN32
	char* p = strtok_s(str, del, &ptr);
	while (p != NULL)
	{
		*result++ = p;
		p = strtok_s(NULL, del, &ptr);
	}
#else
	char* p = strtok_r(str, del, &ptr);
	while (p != NULL)
	{
		*result++ = p;
		p = strtok_r(NULL, del, &ptr);
	}
#endif
}

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::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->m_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, "AudioNames = %s!", pAudioNames);
	m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Audio 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->m_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->m_uFilesCount = uValidCount;
	m_pHostApi->Debug(MEDIA_LOG_DEBUG, "pParam m_uFilesCount = %d", pParam->m_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 Configuration failed while play local audio!");
		return iRet;
	}
	else {
		m_pHostApi->Debug(MEDIA_LOG_DEBUG, "Load Configuration 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::StartPlayMedia(CMediaPlayConfig& config)
{
	int iRet = -1;
	memcpy(&m_stPlayConfig, &config, sizeof(CMediaPlayConfig));

	rvc_media_player_param_t t_param = { 0 };

	t_param.eType = eVideo_Type;
	t_param.m_eWindType = eFullScreen_Type;
	t_param.bvicemonitor = !m_stPlayConfig.bPrimMonitor;
	t_param.idisplaycx = m_stPlayConfig.nWndX;
	t_param.idisplaycy = m_stPlayConfig.nWndY;
	t_param.idisplaywidth = m_stPlayConfig.nWndWidth > 0 ? m_stPlayConfig.nWndWidth : RVC_DEFAULT_VIDEO_WIDTH;
	t_param.idisplayheight = m_stPlayConfig.nWndHeight > 0 ? m_stPlayConfig.nWndHeight : RVC_DEFAULT_VIDEO_HEIGHT;

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

	m_pHostApi->Debug(MEDIA_LOG_DEBUG, "pParam m_uFilesCount = %d", t_param.m_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::StartPlayVideoNotice(int nWndX, int nWndY, int nWndWidth, int nWndHeight, const char* pFileName)
{
	if (NULL == pFileName) {
		return;
	}

	rvc_media_player_param_t t_param = { 0 };
	t_param.m_uFilesCount = 1;
	t_param.eType = eVideo_Type;
	t_param.m_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.m_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;
		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::PlayLocalAudio(const char* pAudioNames)
{
	return m_pImpl->StartPlayLocalAudio(pAudioNames);
}

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