void CRealPlayMgr::FreeRealPlayEx(IVS_ULONG ulHandle)
{
BP_DBG_LOG("Free Real PlayEx", "Free Handle %u", ulHandle);
CRealPlay *pRealPlay = NULL;
(void)VOS_MutexLock(m_pHanleRealPlayMutex);
HandleRealPlayMapIter iter = m_HanleRealPlayMap.find(ulHandle);
if (iter != m_HanleRealPlayMap.end())
{
pRealPlay = iter->second;
m_HanleRealPlayMap.erase(iter++);
}
(void)VOS_MutexUnlock(m_pHanleRealPlayMutex);
if (NULL == pRealPlay)
{
BP_RUN_LOG_ERR(IVS_FAIL, "FreeRealPlayEx", "pRealPlay = NULL");
return;
}
if (0 == pRealPlay->PutRef())
{
BP_DBG_LOG("Free Real PlayEx", "Delete Handle %u", ulHandle);
IVS_DELETE(pRealPlay);
}
}
//开始播放视频
IVS_INT32 CTelepresenceMgr::StartRealPlayByIPEx(const std::string& strCameraCode,
const IVS_REALPLAY_PARAM& RealplayParam,
const IVS_MEDIA_ADDR& stMediaAddrDst,
IVS_MEDIA_ADDR& stMediaAddrSrc,
IVS_ULONG& ulHandle)
{
IVS_DEBUG_TRACE("");
if(0==strCameraCode.length())
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Start RealPlay ByIP", "Camera Code Invalid.");
return IVS_PARA_INVALID;
}
//modify by zwx211831, Date:20140813, UDP协议下音频端口不能为0，TCP可以为0
if(IP_V4!=stMediaAddrDst.stIP.uiIPType
|| (0==stMediaAddrDst.uiAudioPort && (PROTOCOL_RTP_OVER_UDP == (IVS_PROTOCOL_TYPE)RealplayParam.uiProtocolType)
|| PROTOCOL_UDP == (IVS_PROTOCOL_TYPE)RealplayParam.uiProtocolType)
|| 0==stMediaAddrDst.uiVideoPort
)
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Start RealPlay ByIP", "Media Addr Invalid.");
return IVS_PARA_INVALID;
}
CTPPlayChannel* pPlayChannel = GetPlayChannel(ulHandle, TRUE);
if(NULL==pPlayChannel)
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "Start RealPlay ByIP", "Create Play Channel Failed");
return IVS_ALLOC_MEMORY_ERROR;
}
pPlayChannel->SetTPMgr(this);
ulHandle = (IVS_ULONG)pPlayChannel;
IVS_MEDIA_PARA stMediaPara;
memset(&stMediaPara, 0, sizeof(IVS_MEDIA_PARA));
stMediaPara.ProtocolType = (IVS_PROTOCOL_TYPE)RealplayParam.uiProtocolType;
stMediaPara.StreamType = (IVS_STREAM_TYPE)RealplayParam.uiStreamType;
stMediaPara.TransMode = (IVS_MEDIA_TRANS_MODE)RealplayParam.bDirectFirst;
stMediaPara.BroadCastType = (IVS_BROADCAST_TYPE)RealplayParam.bMultiCast;
stMediaPara.VideoDecType = VIDEO_DEC_H264;
stMediaPara.AudioDecType = AUDIO_DEC_G711A;
IVS_INT32 iRet = pPlayChannel->SetMediaParam(&stMediaPara);
if(IVS_SUCCEED!=iRet)
{
BP_RUN_LOG_ERR(iRet, "Start RealPlay ByIP", "Set Media Param Failed");
RemovePlayChannel(ulHandle);
ulHandle = 0;
return iRet;
}
iRet = pPlayChannel->StartRealPlayByIP(strCameraCode, stMediaAddrDst, stMediaAddrSrc);
if(IVS_SUCCEED!=iRet)
{
RemovePlayChannel(ulHandle);
ulHandle = 0;
}
BP_DBG_LOG("CTelepresenceMgr::StartRealPlayByIPEx, Handle: %lu", ulHandle);
return iRet;
}
// 通知流缓冲区状态
IVS_INT32 CPlayback::NotifyStreamBufferState(IVS_INT32 iBufferState)
{
IVS_DEBUG_TRACE("");
// 用户暂停时，不做处理
if (m_bPaused)
{
BP_DBG_LOG("----------In pause state, m_bPaused = true");
return IVS_SUCCEED;
}
return CMediaBase::NotifyStreamBufferState(iBufferState);
}
//开始播放视频
IVS_INT32 CTelepresenceMgr::StartRealPlayByIP(const std::string& strCameraCode,
const IVS_MEDIA_ADDR& stMediaAddrDst,
IVS_MEDIA_ADDR& stMediaAddrSrc,
IVS_ULONG& ulHandle)
{
IVS_DEBUG_TRACE("");
if(0==strCameraCode.length())
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "TP Start Play", "Camera Code Invalid.");
return IVS_PARA_INVALID;
}
if(IP_V4!=stMediaAddrDst.stIP.uiIPType || 0==stMediaAddrDst.uiAudioPort
|| 0==stMediaAddrDst.uiVideoPort)
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "TP Start Play", "Media Addr Invalid.");
return IVS_PARA_INVALID;
}
CTPPlayChannel* pPlayChannel = GetPlayChannel(ulHandle, TRUE);
if(NULL==pPlayChannel)
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "TP Start Play", "Create Play Channel Failed");
return IVS_ALLOC_MEMORY_ERROR;
}
pPlayChannel->SetTPMgr(this);
ulHandle = (IVS_ULONG)pPlayChannel;
IVS_MEDIA_PARA stMediaPara;
memset(&stMediaPara, 0, sizeof(stMediaPara));
stMediaPara.ProtocolType = PROTOCOL_RTP_OVER_UDP;
stMediaPara.StreamType = STREAM_TYPE_MAIN;
stMediaPara.TransMode = MEDIA_TRANS;
stMediaPara.BroadCastType = BROADCAST_UNICAST;
stMediaPara.VideoDecType = VIDEO_DEC_H264;
stMediaPara.AudioDecType = AUDIO_DEC_G711A;
IVS_INT32 iRet = pPlayChannel->SetMediaParam(&stMediaPara);
if(IVS_SUCCEED!=iRet)
{
BP_RUN_LOG_ERR(iRet, "TP Start Play", "Set Media Param Failed");
RemovePlayChannel(ulHandle);
ulHandle = 0;
return iRet;
}
iRet = pPlayChannel->StartRealPlayByIP(strCameraCode, stMediaAddrDst, stMediaAddrSrc);
if(IVS_SUCCEED!=iRet)
{
RemovePlayChannel(ulHandle);
ulHandle = 0;
}
BP_DBG_LOG("CTelepresenceMgr::StartRealPlayByIP, Handle: %lu", ulHandle);
return iRet;
}
// 手动同步创建客户端连接
int CNSSOperator::CreateSyncClientLink(int iNetElementType, const char* pszPeerIP, int iPeerPort, std::string& strNetElementID)const
{
// 连接超时时间默认为5秒
IVS_DEBUG_TRACE("target ip:[%s:%u].", pszPeerIP, iPeerPort);
CREATE_CLIENT_INFO stCreateClientInfoSycn;
memset(&stCreateClientInfoSycn, 0, sizeof(CREATE_CLIENT_INFO));
if (!CToolsHelp::Memcpy(stCreateClientInfoSycn.PeerIP, IP_LENGTH, pszPeerIP, strlen(pszPeerIP)))// 调用位置保证ip以 '\0'结尾
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "memcpy fail", "NA");
return IVS_ALLOC_MEMORY_ERROR;
}
stCreateClientInfoSycn.PeerPort = iPeerPort;
stCreateClientInfoSycn.NetElementType = iNetElementType;
stCreateClientInfoSycn.NeedSwitchId = false;
stCreateClientInfoSycn.uiTimeout = 1;
int iCreateLinkRet = CNetFactory::Instance().CreateClientLinkSyn(stCreateClientInfoSycn);
char cNetElementIDTemp[NET_ELEMENT_ID_LEGTH + 1] = {0};
if (!CToolsHelp::Memcpy(cNetElementIDTemp, NET_ELEMENT_ID_LEGTH + 1, stCreateClientInfoSycn.NetElementID, NET_ELEMENT_ID_LEGTH))// 调用位置保证ip以 '\0'结尾
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "memcpy fail", "NA");
return IVS_ALLOC_MEMORY_ERROR;
}
strNetElementID = cNetElementIDTemp;
BP_DBG_LOG("create sync client link, ret code:%d, target ip:[%s:%u]", iCreateLinkRet, pszPeerIP, iPeerPort);
if (IVS_SUCCEED != iCreateLinkRet)
{
BP_DBG_LOG("fail to create syn link, target ip:[%s:%u], linkid:[%s]", pszPeerIP, iPeerPort, strNetElementID.c_str());
// (void)CNetFactory::Instance().DeleteClientLink(strNetElementID, iNetElementType);
(void)CNetFactory::Instance().DeleteClientLinkByAddr(pszPeerIP, iPeerPort, iNetElementType);
}
return iCreateLinkRet;
}
// 获取视频制式的枚举型
IVS_INT32 CDevEnum::GetVideoFormatEnum(const IVS_CHAR* pVideoType )
{
CHECK_POINTER(pVideoType, IVS_OPERATE_MEMORY_ERROR);
IVS_INT32 iRet = 0;
IVS_INT32 iLen = sizeof(chVideoType)/sizeof(chVideoType[0]);
for (IVS_INT32 i = 0; i < iLen; i++ )
{
if (0 == strcmp(chVideoType[i], pVideoType))
{
iRet = i ;
break;
}
}
BP_DBG_LOG("Get VideoFormatEnum fail", "VideoType=%d",iRet);
return iRet;
}
IVS_INT32 CTPPlayChannel::SetMediaParam(const IVS_MEDIA_PARA* pMediaPara)
{
CHECK_POINTER(pMediaPara, IVS_OPERATE_MEMORY_ERROR);
IVS_DEBUG_TRACE("");
BP_DBG_LOG("StreamType[%d], ProtocolType[%d] TransMode[%d] BroadCastType[%d]",
pMediaPara->StreamType,
pMediaPara->ProtocolType,
pMediaPara->TransMode,
pMediaPara->BroadCastType);
if (STREAM_TYPE_UNSPECIFIED > pMediaPara->StreamType || STREAM_TYPE_SUB2 < pMediaPara->StreamType)//lint !e685
{
BP_RUN_LOG_ERR(IVS_DATA_INVALID, "Set Media Param", "StreamType invalid [%d]", pMediaPara->StreamType);
return IVS_DATA_INVALID;
}
if (PROTOCOL_RTP_OVER_UDP > pMediaPara->ProtocolType || PROTOCOL_RTP_OVER_TCP < pMediaPara->ProtocolType)
{
BP_RUN_LOG_ERR(IVS_DATA_INVALID, "Set Media Param", "ProtocolType invalid [%d]", pMediaPara->ProtocolType);
return IVS_DATA_INVALID;
}
if (MEDIA_TRANS > pMediaPara->TransMode || MEDIA_DIRECT < pMediaPara->TransMode)//lint !e685
{
BP_RUN_LOG_ERR(IVS_DATA_INVALID, "Set Media Param", "TransMode invalid [%d]", pMediaPara->TransMode);
return IVS_DATA_INVALID;
}
if (BROADCAST_UNICAST > pMediaPara->BroadCastType || BROADCAST_MULTICAST < pMediaPara->BroadCastType)//lint !e685
{
BP_RUN_LOG_ERR(IVS_DATA_INVALID, "Set Media Param", "BroadCastType invalid [%d]", pMediaPara->BroadCastType);
return IVS_DATA_INVALID;
}
bool bRet = CToolsHelp::Memcpy(&m_stuMediaParam,sizeof(IVS_MEDIA_PARA), pMediaPara, sizeof(IVS_MEDIA_PARA));
if(false == bRet)
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Set Media Param", "Memcpy error.");
return IVS_ALLOC_MEMORY_ERROR;
}
return IVS_SUCCEED;
}
CRealPlay *CRealPlayMgr::GetFreeRealPlayEx(IVS_ULONG& ulHandle)
{
CRealPlay *pRealPlay = NULL;
pRealPlay = IVS_NEW((CRealPlay*&)pRealPlay);
if (NULL == pRealPlay)
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Get Free RealPlayEx", "create real play error");
return NULL;
}
BP_DBG_LOG("Get Free RealPlayEx", "CreateHandle %u", (unsigned long)pRealPlay);
ulHandle = (unsigned long)pRealPlay;
pRealPlay->SetHandle(ulHandle);
pRealPlay->SetUserMgr(m_pUserMgr);
(void)VOS_MutexLock(m_pHanleRealPlayMutex);
(void)m_HanleRealPlayMap.insert(std::make_pair(ulHandle, pRealPlay));
(void)pRealPlay->GetRef();
(void)VOS_MutexUnlock(m_pHanleRealPlayMutex);
return pRealPlay;
}
//添加平台录像计划;
IVS_INT32 CRecordPlanMgr::AddRecordPlan(IVS_UINT32 uiDeviceNum,const IVS_DEVICE_CODE* pDeviceList,
const IVS_RECORD_PLAN* pRecordPlan,IVS_RESULT_LIST* pResultList,IVS_UINT32 uiResultBufferSize)const
{
CHECK_POINTER(pDeviceList, IVS_PARA_INVALID);
CHECK_POINTER(pRecordPlan, IVS_PARA_INVALID);
CHECK_POINTER(pResultList, IVS_PARA_INVALID);
CHECK_POINTER(m_UserMgr, IVS_OPERATE_MEMORY_ERROR);
IVS_DEBUG_TRACE("");
IVS_UINT32 uiReqBufSize = sizeof(IVS_RESULT_LIST) + (uiDeviceNum-1)*sizeof(IVS_RESULT_INFO);
if (uiReqBufSize > uiResultBufferSize)
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Add Record Plan", "Invalid DeviceNum or BufferSize");
return IVS_PARA_INVALID;
}
if ((RECORD_PLAN_ALLDAY < pRecordPlan->uiRecordPlanType) ||
(PLAN_WEEK == pRecordPlan->uiRecordPlanType && 7 < pRecordPlan->uiPlanInfoNum) ||
(PLAN_DAY == pRecordPlan->uiRecordPlanType && 1 != pRecordPlan->uiPlanInfoNum) ||
(PLAN_ALLDAY == pRecordPlan->uiRecordPlanType && 0 != pRecordPlan->uiPlanInfoNum))
{
pResultList->uiNum = uiDeviceNum;
for (IVS_UINT32 i=0; i<pResultList->uiNum; i++)
{
pResultList->stInfo[i].uiSequence = i;
pResultList->stInfo[i].iResult = IVS_PARA_INVALID;
strncpy(pResultList->stInfo[i].cCode, pDeviceList[i].cDevCode, IVS_DEV_CODE_LEN);
}
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Add Record Plan", "Invalid PlanType or PlanInfoNum");
return IVS_PARA_INVALID;
}
DeviceCodeMap deviceCodeMap;
std::string strSendDomainCode;
CmdMap cmdMap;
CCmd *pCmd = NULL;
IVS_INT32 iRet = m_UserMgr->RecollectCameraDomainCodes2Map(uiDeviceNum,pDeviceList,deviceCodeMap);
DeviceCodeMapIterator deviceCodeMapIter = deviceCodeMap.begin();
DeviceCodeMapIterator deviceCodeMapIterEnd = deviceCodeMap.end();
for (; deviceCodeMapIter != deviceCodeMapIterEnd; deviceCodeMapIter++)
{
DeviceCodeList devList = static_cast<DeviceCodeList>(deviceCodeMapIter->second); //lint !e612 !e69
strSendDomainCode = deviceCodeMapIter->first;//lint !e612
//数据结构拼装XML并转换为const IVS_CHAR *
CXml addRecordPlanXmlReq;
iRet = CRecordXMLProcess::AddOrModRecordPlanGetXML(strSendDomainCode,devList, pRecordPlan, addRecordPlanXmlReq);
if (IVS_SUCCEED != iRet)
{
pResultList->uiNum = uiDeviceNum;
for (IVS_UINT32 i=0; i<pResultList->uiNum; i++)
{
pResultList->stInfo[i].uiSequence = i;
pResultList->stInfo[i].iResult = iRet;
strncpy(pResultList->stInfo[i].cCode, pDeviceList[i].cDevCode, IVS_DEV_CODE_LEN);
}
BP_RUN_LOG_ERR(iRet, "Add Record Plan", "Add Or Mod Record Plan Get XML failed");
return iRet;
}
unsigned int xmlLen = 0;
const IVS_CHAR* pReqPlan = addRecordPlanXmlReq.GetXMLStream(xmlLen);
CHECK_POINTER(pReqPlan, IVS_OPERATE_MEMORY_ERROR);
BP_DBG_LOG("ReqPlan:%s\n", pReqPlan);
//构建发送nss协议
CSendNssMsgInfo sendNssMsgInfo;
sendNssMsgInfo.SetNeedXml(TYPE_NSS_XML);
sendNssMsgInfo.SetNetElemType(NET_ELE_SMU_NSS);
sendNssMsgInfo.SetReqID(NSS_MOD_RECORD_PLAN_REQ);
sendNssMsgInfo.SetReqData(pReqPlan);
sendNssMsgInfo.SetDomainCode(strSendDomainCode.c_str());
pCmd = m_UserMgr->BuildCmd(sendNssMsgInfo);
if (NULL == pCmd)
{
BP_RUN_LOG_INF("build cmd error","cmd req id=%d, domain code=%s",NSS_MOD_RECORD_PLAN_REQ,strSendDomainCode.c_str());
continue;
}
(void)cmdMap.insert(std::make_pair(pCmd->GetTransID(), pCmd));
}
if (cmdMap.empty())
{
return IVS_SUCCEED;
}
IVS_UINT32 uiTimeOut = CSDKConfig::instance().GetTimeOutValue();
std::string strpRsp;
iRet = CDispatcher::instance().dispatcherSyncMsgOutBatch(cmdMap, uiTimeOut);
//IVS_UINT32 iSize = deviceCodeMap.size();
IVS_INT32 iEachRet = 0;
IVS_UINT32 iFailCount = 0;
IVS_UINT32 uiRecordNum = 0;
CmdMapIterator cmdMapIter = cmdMap.begin();
for (; cmdMapIter != cmdMap.end(); cmdMapIter++)
{
CCmd *pCmdRsp = cmdMapIter->second; //lint !e612
if(NULL != pCmdRsp)
{
IVS_CHAR* pRsp = CNSSOperator::instance().ParseCmd2XML(pCmdRsp,iEachRet);
if (IVS_SUCCEED != iEachRet)
{
iFailCount++;
iRet = iEachRet;
BP_RUN_LOG_ERR(iEachRet, "Add Record Plan", "Parse Cmd 2XML failed,rspCode = %d", iEachRet);
// 解析响应的xml
CXml xmlRsp;
if (NULL != pRsp && xmlRsp.Parse(pRsp))
{
iEachRet = CRecordXMLProcess::RecordPlanParseRSP(uiDeviceNum,pDeviceList,pResultList,uiResultBufferSize,xmlRsp,uiRecordNum);
}
}
}
}
if(iFailCount >0)
{
//iRet = IVS_FAIL;
BP_RUN_LOG_ERR(iRet, "Add Platform Record Plan", "Add Platform Record Plan in some Domains failed.");
return iRet;
}
BP_RUN_LOG_INF("Add Platform Record Plan", "ok", "msg have Parsed");
return IVS_SUCCEED;
}//lint !e529
IVS_INT32 CRDAChannel::InitChannel(IVS_UINT32 uiProtocolType, MEDIA_ADDR& stDecoderAddr)
{
// 初始化解码器通道
IPI_INIT_BUSINESS_REQ pParaInfo = {0};
pParaInfo.ulAsyncSeq = m_ulAsyncSeq;
pParaInfo.usChannelNo = static_cast<unsigned short>(m_uiChannel);
bool bSucc = CToolsHelp::Strncpy(pParaInfo.szDecoderID, sizeof(pParaInfo.szDecoderID), m_strDecoderID.c_str(), m_strDecoderID.length());
CHECK_SUCCESS_RET(bSucc, IVS_ALLOC_MEMORY_ERROR);
pParaInfo.ucTransportProtocol = (1==uiProtocolType) ? RDA_PROTOCOL_RTP_OVER_UDP:RDA_PROTOCOL_RTP_OVER_TCP;
m_ucTransportProtocol = pParaInfo.ucTransportProtocol;
IVS_INT32 iRet = IVS_TVWall_InitBusiness(&pParaInfo);
if(IVS_SUCCEED!=iRet)
{
BP_RUN_LOG_ERR(iRet, "Init Channel", "Init Business failed!");
return iRet;
}
BP_DBG_LOG("CRDAChannel::InitChannel: Send Init Channel Info Suc. usChannelNo = %d.", pParaInfo.usChannelNo);
//获取解码器初始化信息，要从中取出媒体IP等信息
CUMW_NOTIFY_INIT_DECODER_INFO decoderInitInfo = {0};
for(int i=0;i<90;i++)
{
//检查是否有停止请求
CHECK_STOP_FLAG_FOR_START();
iRet = m_pTVWallMgr->GetDecoderInitInfo(m_ulAsyncSeq, &decoderInitInfo);
if(IVS_SUCCEED==iRet)
{
m_ulBusinessID = decoderInitInfo.ulBusinessID;
break;
}
VOS_Sleep(70);
}
if(IVS_SUCCEED!=iRet)
{
BP_RUN_LOG_ERR(iRet, "Init Channel", "Get Decoder Init Info Failed!");
HandlePlayException();
return iRet;
}
//检查解码器返回的数据是否为成功
if (IVS_SUCCEED != decoderInitInfo.stErrorCode.ulErrorCode)
{
BP_RUN_LOG_ERR(IVS_TVWALL_DECODER_INIT_CHANNEL_FAIL, "Init Channel", "Init Business failed!");
(void)StopChannel();
HandlePlayException();
return IVS_TVWALL_DECODER_INIT_CHANNEL_FAIL;
}
stDecoderAddr.unMediaIp = htonl((unsigned int)inet_addr(decoderInitInfo.stMediaNetInfo.szMediaIP));
if(decoderInitInfo.stMediaNetInfo.ucTransportProtocol==RDA_PROTOCOL_RTP_OVER_TCP)
{
stDecoderAddr.unMediaVideoPort = decoderInitInfo.stMediaNetInfo.usTcpInterleavedPort;
stDecoderAddr.unMediaAudioPort = decoderInitInfo.stMediaNetInfo.usTcpInterleavedPort;
}
else
{
stDecoderAddr.unMediaVideoPort = decoderInitInfo.stMediaNetInfo.usUdpVideoRtpPort;
stDecoderAddr.unMediaAudioPort = decoderInitInfo.stMediaNetInfo.usUdpAudioRtpPort;
}
BP_DBG_LOG("CRDAChannel::InitChannel, get DecoderInitInfo success: \
DecoderID=%s,TCPPort=%d,UDPVideoPort=%d,UDPAudioPort=%d",
decoderInitInfo.szDecoderID,
decoderInitInfo.stMediaNetInfo.usTcpInterleavedPort,
decoderInitInfo.stMediaNetInfo.usUdpVideoRtpPort,
decoderInitInfo.stMediaNetInfo.usUdpAudioRtpPort);
return IVS_SUCCEED;
}
// 设置播放速度
int CPlayback::SetPlayBackSpeed(float fSpeed)
{
CLockGuard lock(m_pMediaMutex);
(void)IVS_PLAY_SetPlaySpeed(m_ulPlayerChannel, fSpeed);//lint !e747
m_bStepPlay = false;
int iRet = IVS_FAIL;
RTSP_SESSION_STATUS state = RTSP_CLIENT_GetStatus(m_iRtspHandle);
if (!m_bLocalFile)
{
if (RTSP_SESSION_STATUS_PLAYING == state ||
RTSP_SESSION_STATUS_READY == state)
{
float fSendScale = fSpeed;
(void)CToolsHelp::GetSendScale(m_enServiceType,fSpeed, fSendScale);
MEDIA_RANGE_S stRange;
memset(&stRange, 0x0, sizeof(MEDIA_RANGE_S));
stRange.enRangeType = RANGE_TYPE_NPT/*RANGE_TYPE_UTC*/;
stRange.MediaBeginOffset = OFFSET_CUR;
BP_DBG_LOG("SetPlayBackSpeed, m_fSpeed:[%f], fSpeed:[%f].", m_fSpeed, fSpeed);
/*
* DTS2013020300831,
* 回放方向发生变化，对播放时间偏移重新定位,避免中间暂停
* fix by w00210470
*/
if ((m_fSpeed < 0 && fSpeed > 0) ||
(m_fSpeed > 0 && fSpeed < 0))
{
IVS_PLAY_SetResetFlag(m_ulPlayerChannel, false);
unsigned long long current = 0;
(void)IVS_PLAY_GetCurrentFrameTick(m_ulPlayerChannel, ¤t);
if (current && ((long long)(current/1000) > m_tmStart))
{
stRange.MediaBeginOffset = current/1000 - m_tmStart;//lint !e737 !e712
//IVS_PLAY_ResetData(m_ulPlayerChannel);
BP_DBG_LOG("Set Play Back Speed, direction is change, m_fSpeed:[%f], fSpeed:[%f].", m_fSpeed, fSpeed);
}
}
else if (((m_fSpeed >= 8.000000) && (fSpeed < 8.000000))
|| ((m_fSpeed < 8.000000) && (fSpeed >= 8.000000))
|| ((m_fSpeed <= -2.000000) && (fSpeed > -2.000000))
|| ((m_fSpeed > -2.000000) && (fSpeed <= -2.000000)))
{
unsigned long long current = 0;
(void)IVS_PLAY_GetCurrentFrameTick(m_ulPlayerChannel, ¤t);
if (current && ((long long)(current/1000) > m_tmStart))
{
stRange.MediaBeginOffset = current/1000 - m_tmStart;//lint !e737 !e712
//IVS_PLAY_ResetData(m_ulPlayerChannel);
BP_DBG_LOG("Set Play Back Speed, m_fSpeed:[%f], fSpeed:[%f].", m_fSpeed, fSpeed);
}
}
iRet = RTSP_CLIENT_SendPlayMsg(m_iRtspHandle, m_stMediaRsp.szURL, (double)fSendScale, &stRange, RTSP_CLIENT_TIMEOUT);
if (0 != iRet)
{
BP_RUN_LOG_ERR(iRet,"Play Back Resume", "IVS pause play fail.");
return IVS_PLAYER_RET_RTSP_SEND_PLAY_FAIL;
}
//必须调用接口清空流控标志，否则会导致缓冲区满但不会发PAUSE消息，造成丢包花屏
IVS_PLAY_ReSetFlowContrlFlag(m_ulPlayerChannel);
//正向播放8/16时只有I帧，本域反向播放-2/-4/-8/-16时只有I帧;外域反向都是I帧
if (((m_fSpeed < 8.000000) && (fSpeed >= 8.000000))
|| ((m_fSpeed > -2.000000) && (fSpeed <= -2.000000))
|| ((m_fSpeed >= 8.000000) && (fSpeed < 8.000000)))
{
IVS_PLAY_ResetData(m_ulPlayerChannel);
IVS_PLAY_SetResetFlag(m_ulPlayerChannel, false);
}
else if ((m_fSpeed <= -2.000000) && (fSpeed > -2.000000))
{
IVS_PLAY_ResetData(m_ulPlayerChannel);
IVS_PLAY_SetResetFlag(m_ulPlayerChannel, true);
}
}
}
m_fSpeed = fSpeed;
return IVS_SUCCEED;
}
/*
* StepBackward
* 单步后退
*/
int CPlayback::StepBackward()
{
CLockGuard lock(m_pMediaMutex);
if (!m_bLocalFile)
{
if (!m_bStepPlay || m_fSpeed > 0)
{
float fSpeed = -1.0;
float fSendScale = fSpeed;
(void)CToolsHelp::GetSendScale(m_enServiceType,fSpeed, fSendScale);
MEDIA_RANGE_S stRange;
memset(&stRange, 0x0, sizeof(MEDIA_RANGE_S));
stRange.enRangeType = RANGE_TYPE_NPT;
stRange.MediaBeginOffset = OFFSET_CUR;
unsigned long long current = 0;
if ((m_fSpeed < 0 && fSpeed > 0) ||
(m_fSpeed > 0 && fSpeed < 0))
{
//unsigned long long current = 0;
(void)IVS_PLAY_GetCurrentFrameTick(m_ulPlayerChannel, ¤t);
if (current && ((long long)(current/1000) > m_tmStart))
{
stRange.MediaBeginOffset = current/1000 - m_tmStart;//lint !e737 !e712
}
}
else if ((m_fSpeed == -16.000000) && (fSpeed == -1.000000)
|| (m_fSpeed == -8.000000) && (fSpeed == -1.000000)
|| (m_fSpeed == -4.000000) && (fSpeed == -1.000000))
{
//unsigned long long current = 0;
(void)IVS_PLAY_GetCurrentFrameTick(m_ulPlayerChannel, ¤t);
if (current && ((long long)(current/1000) > m_tmStart))
{
stRange.MediaBeginOffset = current/1000 - m_tmStart;//lint !e737 !e712
BP_DBG_LOG("16 Step Backward, m_fSpeed:[%f], fSpeed:[%f].", m_fSpeed, fSpeed);
}
}
int iRet = RTSP_CLIENT_SendPlayMsg(m_iRtspHandle, m_stMediaRsp.szURL, (double)fSendScale, &stRange, RTSP_CLIENT_TIMEOUT);
if (0 != iRet)
{
BP_RUN_LOG_ERR(iRet,"Play Back Resume", "IVS pause play fail.");
return IVS_PLAYER_RET_RTSP_SEND_PLAY_FAIL;
}
if ((m_fSpeed == -16.000000) && (fSpeed == -1.000000)
|| (m_fSpeed == -8.000000) && (fSpeed == -1.000000)
|| (m_fSpeed == -4.000000) && (fSpeed == -1.000000))
{
//IVS_PLAY_SetPlayTime(m_ulPlayerChannel, current/1000);
IVS_PLAY_ResetData(m_ulPlayerChannel);
IVS_PLAY_SetResetFlag(m_ulPlayerChannel, true);
}
}
}
m_fSpeed = -1.0;
m_bStepPlay = true;
m_bPaused = false;
unsigned long framesLeft = 0;
(void)IVS_PLAY_StepPlayBackward(m_ulPlayerChannel, &framesLeft);
return IVS_SUCCEED;
}
IVS_INT32 CTelepresenceMgr::StartPlatformPlayBackByIP(const std::string& strCameraCode,
const IVS_PLAYBACK_PARAM& stPlaybackParam,
const IVS_MEDIA_ADDR& stMediaAddrDst,
IVS_MEDIA_ADDR& stMediaAddrSrc,
IVS_ULONG& ulHandle)
{
IVS_DEBUG_TRACE("");
if(0==strCameraCode.length())
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Start Platform PlayBack ByIP", "Camera Code Invalid.");
return IVS_PARA_INVALID;
}
//modify by zwx211831, Date:20140813, UDP协议下音频端口不能为0，TCP可以为0
if(IP_V4!=stMediaAddrDst.stIP.uiIPType
|| (0==stMediaAddrDst.uiAudioPort && (PROTOCOL_RTP_OVER_UDP == (IVS_PROTOCOL_TYPE)stPlaybackParam.uiProtocolType)
|| PROTOCOL_UDP == (IVS_PROTOCOL_TYPE)stPlaybackParam.uiProtocolType)
|| 0==stMediaAddrDst.uiVideoPort
)
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID, "Start Platform PlayBack ByIP", "Media Addr Invalid.");
return IVS_PARA_INVALID;
}
TIME_SPAN_INTERNAL stTimeSpanInter;
memset(&stTimeSpanInter, 0, sizeof(TIME_SPAN_INTERNAL));
IVS_INT32 iRet = CheckParam(&stPlaybackParam.stTimeSpan, stPlaybackParam.uiProtocolType, stPlaybackParam.fSpeed, stTimeSpanInter);
if (IVS_SUCCEED != iRet)
{
BP_RUN_LOG_ERR(IVS_PARA_INVALID,"Start Platform PlayBack ByIP", "CheckParam failed.");
return IVS_PARA_INVALID;
}
CTPPlayChannel* pPlayChannel = GetPlayChannel(ulHandle, TRUE);
if(NULL==pPlayChannel)
{
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR, "Start Platform PlayBack ByIP", "Create Play Channel Failed");
return IVS_ALLOC_MEMORY_ERROR;
}
pPlayChannel->SetTPMgr(this);
ulHandle = (IVS_ULONG)pPlayChannel;
IVS_MEDIA_PARA stMediaPara;
memset(&stMediaPara, 0, sizeof(IVS_MEDIA_PARA));
stMediaPara.DecoderCompany = VENDOR_HUAWEI;
stMediaPara.StreamType = STREAM_TYPE_MAIN;
stMediaPara.TransMode = MEDIA_TRANS;
stMediaPara.BroadCastType = BROADCAST_UNICAST;
stMediaPara.VideoDecType = VIDEO_DEC_H264;
stMediaPara.AudioDecType = AUDIO_DEC_G711A;
stMediaPara.ProtocolType = static_cast<IVS_PROTOCOL_TYPE>(stPlaybackParam.uiProtocolType);
iRet = pPlayChannel->SetMediaParam(&stMediaPara);
if(IVS_SUCCEED!=iRet)
{
BP_RUN_LOG_ERR(iRet, "Start Platform PlayBack ByIP", "Set Media Param Failed");
RemovePlayChannel(ulHandle);
ulHandle = 0;
return iRet;
}
iRet = pPlayChannel->StartPlatformPlayBackByIP(strCameraCode, stMediaAddrDst, stMediaAddrSrc, stTimeSpanInter, stPlaybackParam.fSpeed);
if(IVS_SUCCEED!=iRet)
{
RemovePlayChannel(ulHandle);
ulHandle = 0;
}
BP_DBG_LOG("CTelepresenceMgr::StartPlatformPlayBackByIP, Handle: %lu", ulHandle);
return iRet;
}
//开始播放视频
IVS_INT32 CTPPlayChannel::StartRealPlayByIP(const std::string& strCameraCode,
const IVS_MEDIA_ADDR& stMediaAddrDst,
IVS_MEDIA_ADDR& stMediaAddrSrc)
{
IVS_DEBUG_TRACE("");
//如果该通道正在播放，则关闭
if(m_iRtspHandle>0)
{
(void)StopPlayByIP();
}
//获取媒体URL
ST_MEDIA_RSP mediaRsp;
memset(&mediaRsp, 0, sizeof(ST_MEDIA_RSP));
IVS_INT32 iRet = GetRealPlayURL(strCameraCode, stMediaAddrDst, mediaRsp);
if (IVS_SUCCEED != iRet || 0 == strlen(mediaRsp.szURL))
{
BP_RUN_LOG_ERR(iRet,"TP Start Play Req", "get URL failed!");
return iRet;
}
BP_DBG_LOG("CTPPlayChannel::StartRealPlayByIP, get URL success: url = %s",mediaRsp.szURL);
m_strURL = mediaRsp.szURL;
// 建立RTSP连接
iRet = RTSP_CLIENT_GetHandle(true, &m_iRtspHandle);
if (IVS_SUCCEED != iRet || 0==m_iRtspHandle)
{
BP_RUN_LOG_ERR(IVS_PLAYER_RET_RTSP_GET_HANDLE_FAIL,"TP Start Play", "Rtsp client get handle fail.");
return IVS_PLAYER_RET_RTSP_GET_HANDLE_FAIL;
}
// setup
MEDIA_ADDR stTPMCUAddr = {0}; //智真媒体服务器
MEDIA_ADDR stMUMediaAddr = {0}; //MU
INET_ADDR stServiceAddr = {0};
bool bTcpFlag = false;
stTPMCUAddr.unMediaIp = htonl((unsigned int)inet_addr(stMediaAddrDst.stIP.cIP));
stTPMCUAddr.unMediaVideoPort = static_cast<unsigned short>(stMediaAddrDst.uiVideoPort);
stTPMCUAddr.unMediaAudioPort = static_cast<unsigned short>(stMediaAddrDst.uiAudioPort);
stServiceAddr.unAddrIp = htonl((unsigned int)inet_addr(mediaRsp.szRTSPIP));
stServiceAddr.unAddrPort = (unsigned short)atoi(mediaRsp.szRTSPPORT);
iRet = RTSP_CLIENT_SetDataCallBack(m_iRtspHandle, RtspDataCallBack, this);
iRet += RTSP_CLIENT_SendSetupMsg(m_iRtspHandle, &stServiceAddr, mediaRsp.szURL, RTSP_CLIENT_TIMEOUT, bTcpFlag, &stTPMCUAddr, &stMUMediaAddr);
if (IVS_SUCCEED != iRet)
{
(void)RTSP_CLIENT_SendTeardownMsg(m_iRtspHandle, mediaRsp.szURL, 1);
(void)RTSP_CLIENT_FreeHandle(m_iRtspHandle);
m_iRtspHandle = 0;
BP_RUN_LOG_ERR(CMediaBase::GetRtspErrorCode(iRet),"TP Start Play", "Send Setup Message failed, rtsp errcode=%d.", iRet);
return CMediaBase::GetRtspErrorCode(iRet);
}
if(0==stMUMediaAddr.unMediaVideoPort && 0==stMUMediaAddr.unMediaAudioPort)
{
(void)RTSP_CLIENT_SendTeardownMsg(m_iRtspHandle, mediaRsp.szURL, 1);
(void)RTSP_CLIENT_FreeHandle(m_iRtspHandle);
m_iRtspHandle = 0;
BP_RUN_LOG_ERR(IVS_SDK_PLAYBACK_ERR_GET_REMOTE_DATAINFO,"TP Start Play", "Setup Message return port=0.");
return IVS_SDK_PLAYBACK_ERR_GET_REMOTE_DATAINFO;
}
stMediaAddrSrc.uiAudioPort = stMUMediaAddr.unMediaAudioPort;
stMediaAddrSrc.uiVideoPort = stMUMediaAddr.unMediaVideoPort;
std::string strIP;
if(IVS_SUCCEED!=CMediaBase::AddrUint2Char(ntohl(stMUMediaAddr.unMediaIp), strIP))
{
(void)RTSP_CLIENT_SendTeardownMsg(m_iRtspHandle, mediaRsp.szURL, 1);
(void)RTSP_CLIENT_FreeHandle(m_iRtspHandle);
m_iRtspHandle = 0;
BP_RUN_LOG_ERR(IVS_PARA_INVALID,"TP Start Play","Parse Media IP Failed!");
return IVS_PARA_INVALID;
}
bool bSucc = CToolsHelp::Strncpy(stMediaAddrSrc.stIP.cIP, sizeof(stMediaAddrSrc.stIP.cIP), strIP.c_str(), strIP.length());
if(!bSucc)
{
(void)RTSP_CLIENT_SendTeardownMsg(m_iRtspHandle, mediaRsp.szURL, 1);
(void)RTSP_CLIENT_FreeHandle(m_iRtspHandle);
m_iRtspHandle = 0;
BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"TP Start Play","Copy Media IP Failed!");
return IVS_ALLOC_MEMORY_ERROR;
}
BP_DBG_LOG("CTPPlayChannel::StartRealPlayByIP, Media IP: %s, VideoPort: %u, AutioPort: %u",
stMediaAddrSrc.stIP.cIP, stMediaAddrSrc.uiVideoPort, stMediaAddrSrc.uiAudioPort);
// play
MEDIA_RANGE_S stMdieaRange;
ULONG ulStartTime = 0;
double dScale = 1.0;
memset(&stMdieaRange, 0x0, sizeof(MEDIA_RANGE_S));
stMdieaRange.enRangeType = RANGE_TYPE_NPT;
stMdieaRange.MediaBeginOffset = ulStartTime;
iRet = RTSP_CLIENT_SendPlayMsg(m_iRtspHandle, mediaRsp.szURL, dScale, &stMdieaRange, RTSP_CLIENT_TIMEOUT);
if (IVS_SUCCEED != iRet)
{
(void)RTSP_CLIENT_SendTeardownMsg(m_iRtspHandle, mediaRsp.szURL, 1);
(void)RTSP_CLIENT_FreeHandle(m_iRtspHandle);
BP_RUN_LOG_ERR(iRet, "TP Start Play", "Send Play Message failed.");
return IVS_PLAYER_RET_RTSP_SEND_PLAY_FAIL;
}
return IVS_SUCCEED;
}
//域路由
IVS_INT32 CDomainRouteMgr::GetDomainRoute(IVS_DOMAIN_ROUTE_LIST* pDomainRouteList, IVS_UINT32 uiBufferSize )
{
BP_RUN_LOG_INF("Get DomainRoute", "Enter");
CHECK_POINTER(pDomainRouteList, IVS_OPERATE_MEMORY_ERROR);
CHECK_POINTER(m_pUserMgr, IVS_OPERATE_MEMORY_ERROR);
//如果超出最大的数量则返回错误,一个系统最多128*8个域
//IVS_UINT32 uiMapLen = m_domainCodeMap.size();
if ((IVS_MAX_DOMAIN_ROUTE_NUM * 8) < m_domainCodeMap.size())
{
BP_RUN_LOG_ERR(IVS_OPERATE_MEMORY_ERROR, "Get DomainRoute", "Request Buffer Size Not Enough, DomainCount[%d].", m_domainCodeMap.size());
return IVS_OPERATE_MEMORY_ERROR;
}
CXml xmlRsp;
IVS_INT32 iRet = SendCmdAndGetInfo(xmlRsp);
if (IVS_SUCCEED == iRet)
{
iRet = GeDomainRouteParseXML(pDomainRouteList, xmlRsp);
}
m_proxyDomainCodeMap.clear(); // 清除代理域map
IVS_CHAR szDomainCode[IVS_DOMAIN_CODE_LEN + 1] = {0};
for (int i = 0; i < pDomainRouteList->uiTotal; i++)
{
memset(szDomainCode, 0, sizeof(szDomainCode));
strncpy(szDomainCode, pDomainRouteList->stDomainRoute[i].cDomainCode, IVS_DOMAIN_CODE_LEN);
if (pDomainRouteList->stDomainRoute[i].bIsLocalDomain)
{
BP_DBG_LOG("get domain list, Local domain:[%s-%s:%u] is online.", szDomainCode,
pDomainRouteList->stDomainRoute[i].stIP.cIP, pDomainRouteList->stDomainRoute[i].uiPort);
continue;
}
CLinkInfo oLinkIDInfoTemp;
if (DEV_STATUS_ONLINE == pDomainRouteList->stDomainRoute[i].uiStatus)
{
oLinkIDInfoTemp.Init(NET_ELE_SMU_NSS, LINKID_STATUS_ENABLED, "", szDomainCode, pDomainRouteList->stDomainRoute[i].stIP.cIP, "");
(void)CLinkRouteMgr::instance().UpdateLinkInfo(m_pUserMgr->GetSessionID(), oLinkIDInfoTemp, true);
BP_DBG_LOG("get domain list, domain:[%s-%s:%u] is online.", szDomainCode,
pDomainRouteList->stDomainRoute[i].stIP.cIP, pDomainRouteList->stDomainRoute[i].uiPort);
}
else
{
oLinkIDInfoTemp.Init(NET_ELE_SMU_NSS, LINKID_STATUS_CLOSED, "", szDomainCode, pDomainRouteList->stDomainRoute[i].stIP.cIP, "");
(void)CLinkRouteMgr::instance().UpdateLinkInfo(m_pUserMgr->GetSessionID(), oLinkIDInfoTemp, true);
// 当前域不可用，添加到重连列表中(键值为 IP + Port)
m_pUserMgr->AddLinkIdToBusinessResumeList("", NET_ELE_SMU_NSS, pDomainRouteList->stDomainRoute[i].stIP.cIP,
pDomainRouteList->stDomainRoute[i].uiPort, TYPE_ADD_RELINK);
BP_RUN_LOG_INF("get domain list,", "domain:[%s-%s:%u] is offline, have been push into resume list.", szDomainCode,
pDomainRouteList->stDomainRoute[i].stIP.cIP, pDomainRouteList->stDomainRoute[i].uiPort);
}
}
BP_RUN_LOG_INF("CDeviceMgr::GetDomainRoute", "Leave");
return iRet;
}//lint !e529 !e830
