浅析live555媒体库之实现实时码流预览
前面已经介绍了，通过live555来实现媒体文件的播放。这篇主要和大家说一下实时流的通过live555的播放。
相对之前的文件流，这里实时流只需要多实现一个子类：通过继承RTSPServer类来实现一些自己的相关操作。
如：有客户端请求过来的时候，需要先通过lookupServerMediaSession找到对应的session，这里可以定义自己的streamName，也就是url后面按个串，。如果没有找到，则新建生成自己需要的不同的session，还有填充自己的SDP信息等等操作。
继承RTSPServer的子类实现如下：具体的一些实现可以参考RTSPServer的实现，只需要修改填充自己的session的即可。
#include "DemoH264RTSPServer.h"
#include "DemoH264Interface.h"
#include "DemoH264MediaSubsession.h"
DemoH264RTSPServer* DemoH264RTSPServer::createNew(UsageEnvironment& env, Port rtspPort,
UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds)
{
int rtspSock = -1;
rtspSock = setUpOurSocket(env, rtspPort);
if(rtspSock == -1 )
{
DBG_LIVE555_PRINT("setUpOurSocket failed\n");
return NULL;
}
return new DemoH264RTSPServer(env, rtspSock, rtspPort, authDatabase, reclamationTestSeconds);
}
DemoH264RTSPServer::DemoH264RTSPServer(UsageEnvironment& env, int ourSock, Port rtspPort, UserAuthenticationDatabase* authDatabase,
unsigned reclamationTestSeconds):RTSPServer(env, ourSock, rtspPort, authDatabase, reclamationTestSeconds), fRTSPServerState(true)
{
DBG_LIVE555_PRINT("create DemoH264RTSPServer \n");
}
DemoH264RTSPServer::~DemoH264RTSPServer()
{
}
ServerMediaSession* DemoH264RTSPServer::lookupServerMediaSession(const char* streamName)
{
// streamName, 为URL地址后面的字符串 如
// rtsp://10.0.2.15/streamNameCH00StreamType00, 则streamName = "streamNameCH00StreamType00";
// 当客户端发来url请求时，可以解析streamName来判断请求那个通道的哪种码流
// 1 解析url 我这里不处理，可以自己回调接口进来处理
int channelNO = 0; // 通道号
int streamType = 0; // 码流类型
int videoType = 1; // 视频 or 音频
int requestType = 0; // 请求类型 实时预览 or 回放
ServerMediaSession* sms = NULL;
switch(requestType)
{
case 0: // realtime
sms = RTSPServer::lookupServerMediaSession(streamName);
if ( NULL == sms )
{
sms = ServerMediaSession::createNew(envir(), streamName, NULL, NULL);
DemoH264MediaSubsession *session = DemoH264MediaSubsession::createNew(envir(), streamType, videoType, channelNO, false);
sms->addSubsession(session);
}
break;
case 1:
// play back
DBG_LIVE555_PRINT("play back request !\n");
break;
default:
DBG_LIVE555_PRINT("unknown request type!\n");
break;
}
this->addServerMediaSession(sms);
return sms;
}
DemoH264RTSPServer::DemoH264RTSPClientSession* DemoH264RTSPServer::createNewClientSession(unsigned clientSessionID, int clientSocket, struct sockaddr_in clientAddr)
{
DemoH264RTSPServer::DemoH264RTSPClientSession* client = new DemoH264RTSPClientSession(*this, clientSessionID, clientSocket, clientAddr);
fClientSessionList.push_back(client);
DBG_LIVE555_PRINT("add client session success!\n");
return client;
}
int DemoH264RTSPServer::stopDemoH264RTSPServer()
{
// 删除所有的客户端的session
std::list<DemoH264RTSPServer::DemoH264RTSPClientSession*> ::iterator pos =
this->fClientSessionList.begin();
for(pos; pos != this->fClientSessionList.end(); pos ++ )
{
DemoH264RTSPServer::DemoH264RTSPClientSession* tmp = *pos;
delete tmp;
}
delete this; //
return 0;
}
DemoH264RTSPServer::DemoH264RTSPClientSession::DemoH264RTSPClientSession(DemoH264RTSPServer& rtspServer,unsigned clietnSessionID, int clientSocket, struct sockaddr_in clientAddr):
RTSPServer::RTSPClientSession(rtspServer, clietnSessionID, clientSocket, clientAddr)
{
}
DemoH264RTSPServer::DemoH264RTSPClientSession::~DemoH264RTSPClientSession()
{
/*
std::list<DemoH264RTSPServer::DemoH264RTSPClientSession*> ::iterator pos =
((DemoH264RTSPServer&)fOurServer).fClientSessionList.begin();
for(pos; pos != ((DemoH264RTSPServer&)fOurServer).fClientSessionList.end(); pos ++ )
{
if ((*pos)->fOurSessionId == this->fOurSessionId)
{
((DemoH264RTSPServer&)fOurServer).fClientSessionList.erase(pos);
DBG_LIVE555_PRINT("client session has been delete !\n");
break ;
}
}
*/
}
因为这些实现，就要请求不同的码流类型，主次码流，或者音频视频这些，所以Source和Session的子类实现也得作相应的修改：
#include "DemoH264FrameSource.h"
#include "DemoH264Interface.h"
DemoH264FrameSource::DemoH264FrameSource(UsageEnvironment& env, long sourceHandle, int sourceType):
FramedSource(env), fSourceHandle(sourceHandle), fLastBufSize(0), fLeftDataSize(0), fSourceType(sourceType), fFirstFrame(1)
{
// 打开流媒体文件，在实时流时，这里就是开始传送流之前的一些准备工作
fDataBuf = (char*)malloc(2*1024*1024);
if(fDataBuf == NULL )
{
DBG_LIVE555_PRINT(" create source data buf failed!\n");
}
}
DemoH264FrameSource::~DemoH264FrameSource()
{
if(fDataBuf)
{
free(fDataBuf);
fDataBuf = NULL;
}
}
DemoH264FrameSource* DemoH264FrameSource::createNew(UsageEnvironment& env, int streamType, int channelNO, int sourceType)
{
//通过streamType和channelNO来创建source，向前端请求对应的码流//
long sourceHandle = openStreamHandle(channelNO, streamType);
if(sourceHandle == 0)
{
DBG_LIVE555_PRINT("open the source stream failed!\n");
return NULL;
}
DBG_LIVE555_PRINT("create H264FrameSource !\n");
return new DemoH264FrameSource(env, sourceHandle, sourceType);
}
/* 获取需要读取文件的总长度，live555对每次数据的发送有长度限制 */
long filesize(FILE *stream)
{
long curpos, length;
curpos = ftell(stream);
fseek(stream, 0L, SEEK_END);
length = ftell(stream);
fseek(stream, curpos, SEEK_SET);
return length;
}
void DemoH264FrameSource::doGetNextFrame()
{
int ret = 0;
//调用设备接口获取一帧数据
if (fLeftDataSize == 0)
{
ret = getStreamData(fSourceHandle, fDataBuf,&fLastBufSize, &fLeftDataSize,fSourceType);
if (ret <= 0)
{
DBG_LIVE555_PRINT("getStreamData failed!\n");
return;
}
}
int fNewFrameSize = fLeftDataSize;
if(fNewFrameSize > fMaxSize)
{ // the fMaxSize data
fFrameSize = fMaxSize;
fNumTruncatedBytes = fNewFrameSize - fMaxSize;
fLeftDataSize = fNewFrameSize - fMaxSize;
// 注意memmove函数的用法，允许内存空间叠加的
memmove(fTo, fDataBuf, fFrameSize);
memmove(fDataBuf, fDataBuf+fMaxSize, fLeftDataSize);
}
else
{ //all the data
fFrameSize = fNewFrameSize;
fLeftDataSize = 0;
memmove(fTo, fDataBuf, fFrameSize);
}
gettimeofday(&fPresentationTime, NULL);
if (fFirstFrame)
{
fDurationInMicroseconds = 40000;
nextTask() = envir().taskScheduler().scheduleDelayedTask(100000,
(TaskFunc*)FramedSource::afterGetting, this);
fFirstFrame = 0;
}
else
{
FramedSource::afterGetting(this);
}
}
void DemoH264FrameSource::doStopGetFrame()
{
closeStreamHandle(fSourceHandle);
}
session的子类实现
#include "DemoH264MediaSubsession.h"
#include "DemoH264FrameSource.h"
#include "DemoH264Interface.h"
#include "H264VideoStreamFramer.hh"
#include "H264VideoRTPSink.hh"
DemoH264MediaSubsession::DemoH264MediaSubsession(UsageEnvironment& env, int streamType, int videoType, int channelNO, bool reuseFirstSource, portNumBits initalNumPort)
:OnDemandServerMediaSubsession(env, reuseFirstSource), fStreamType(streamType), fVideoType(videoType), fChannelNO(channelNO)
{
}
DemoH264MediaSubsession::~DemoH264MediaSubsession()
{
}
DemoH264MediaSubsession* DemoH264MediaSubsession::createNew(UsageEnvironment& env, int streamType, int videoType, int channelNO,
bool reuseFirstSource, portNumBits initalNumPort)
{
DemoH264MediaSubsession* sms = new DemoH264MediaSubsession(env, streamType, videoType, channelNO, reuseFirstSource, initalNumPort);
return sms;
}
FramedSource* DemoH264MediaSubsession::createNewStreamSource(unsigned clientsessionId, unsigned& estBitrate)
{
DBG_LIVE555_PRINT("create new stream source !\n");
//这里根据实际请求的类型创建不同的source对象
if(fVideoType == 0x01)
{ // H264 video
estBitrate = 2000; // kbps
DemoH264FrameSource * source = DemoH264FrameSource::createNew(envir(), fStreamType, fChannelNO, 0);
if ( source == NULL )
{
DBG_LIVE555_PRINT("create source failed videoType:%d!\n", fVideoType );
return NULL;
}
return H264VideoStreamFramer::createNew(envir(), source);
}
else if ( fVideoType == 0x2)
{// Mpeg-4 video
}
else if( fVideoType == 0x04)
{ // G711 audio
estBitrate = 128; // kbps
DemoH264FrameSource * source = DemoH264FrameSource::createNew(envir(), fStreamType, fChannelNO, 1);
if ( source == NULL )
{
DBG_LIVE555_PRINT("create source failed videoType:%d!\n", fVideoType );
return NULL;
}
return source;
}
else
{ // unknow type
}
return NULL;
}
RTPSink* DemoH264MediaSubsession::createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource)
{
// 这里可以根据类型的不同创建不同sink
// 根据实际开发需要，继承不同的子类
DBG_LIVE555_PRINT("createNewRTPnk videoType:%d!\n", fVideoType );
if( fVideoType == 0x01)
{
return H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
}
else if( fVideoType == 0x02)
{ // Mpeg-4
}
else if(fVideoType == 0x04)
{// G711 audio
}
else
{ // unknow type ;
return NULL;
}
}
/* 根据开发实际情况填写SDP信息 */
/*
char const* DemoH264MediaSubsession::sdpLines()
{
// create sdp info
return fSDPLines;
}
*/
最后一个Interface的类，主要是封装一些live555的处理操作以及实时获取码流数据的接口(自己可以根据实际情况写成回调或者其他，看怎么实现方便)，方便其他地方的调用。
#include "DemoH264Interface.h"
#include "DemoH264RTSPServer.h"
/*打开实时码流句柄*/
long openStreamHandle(int channelNO, int streamType)
{
//开始实时流的一些准备工作:获取此类型实时码流的句柄，方便后面直接get码流
// 我这里测试，所以还是用自己定义的文件码流来读，不过每次都是读一帧数据
// 文件流格式为 FrameHeader_S + H264 + FrameHeader_S + H264 ...
FILE* fp = fopen("stream264file.h264", "rb+");
if (NULL == fp )
{
DBG_LIVE555_PRINT("open streamhandle failed!\n");
return -1;
}
return (long)fp;
}
/*实时获取一帧数据*/
int getStreamData(long lHandle, char* buf, unsigned* bufsize, unsigned* leftbufsize, int sourcetype)
{
if(lHandle <= 0)
{
DBG_LIVE555_PRINT(" lHandle error !\n");
return -1;
}
FrameHead_S stFrameHead;
memset(&stFrameHead, 0, sizeof(FrameHead_S));
FILE* fp = (FILE*)lHandle;
int readlen = 0;
// 1、先读取一帧数据的头信息
readlen = fread(&stFrameHead, 1, sizeof(FrameHead_S), fp);
if( readlen != sizeof(FrameHead_S))
{
DBG_LIVE555_PRINT(" read Frame Header Failed !\n");
return -1;
}
//2、获取一帧H264实时数据
if(stFrameHead.FrameLen > 2*1024*1024) // 在source中databuf指分配了2M
{
DBG_LIVE555_PRINT("data is too long:framlen=%d\n", stFrameHead.FrameLen);
//重新分配内存处理
return 0;
}
readlen = fread(buf, 1, stFrameHead.FrameLen, fp);
if(readlen != stFrameHead.FrameLen)
{
DBG_LIVE555_PRINT("read Frame rawdata Failed!\n");
return -1;
}
return stFrameHead.FrameLen;
}
/*关闭码流句柄*/
void closeStreamHandle(long lHandle)
{
//一些关闭码流的清理工作
fclose((FILE*)lHandle);
}
DemoH264Interface* DemoH264Interface::m_Instance = NULL;
DemoH264Interface* DemoH264Interface::createNew()
{
if(NULL == m_Instance)
{
m_Instance = new DemoH264Interface();
}
return m_Instance;
}
DemoH264Interface::DemoH264Interface()
{
m_liveServerFlag = false;
}
DemoH264Interface::~DemoH264Interface()
{
}
void DemoH264Interface::InitLive555(void *param)
{
//初始化
DBG_LIVE555_PRINT(" ~~~~Init live555 stream\n");
// Begin by setting up the live555 usage environment
m_scheduler = BasicTaskScheduler::createNew();
m_env = BasicUsageEnvironment::createNew(*m_scheduler);
#if ACCESS_CONTROL // 认证
m_authDB = new UserAuthenticationDatabase;
m_authDB->addUserRecord("username", "password");
#endif
m_rtspServer = NULL;
m_rtspServerPortNum = 554; // 可以修改
m_liveServerFlag = true;
}
int DemoH264Interface::startLive555()
{
if( !m_liveServerFlag)
{
DBG_LIVE555_PRINT("Not Init the live server !\n");
return -1;
}
DBG_LIVE555_PRINT(" ~~~~Start live555 stream\n");
// 建立RTSP服务
m_rtspServer = DemoH264RTSPServer::createNew(*m_env, m_rtspServerPortNum, m_authDB);
if( m_rtspServer == NULL)
{
// *m_env << " create RTSPServer Failed:" << m_env->getResultMsg() << "\n";
DBG_LIVE555_PRINT("create RTSPServer Failed:%s\n", m_env->getResultMsg());
return -1;
}
// loop and not come back~
m_env->taskScheduler().doEventLoop();
return 0;
}
int DemoH264Interface::stopLive555()
{
DBG_LIVE555_PRINT(" ~~~~stop live555 stream\n");
if(m_liveServerFlag)
{
if(m_rtspServer)
m_rtspServer->stopDemoH264RTSPServer();
m_liveServerFlag = false;
}
}
最后相当于一个demo调用程序：
#include <stdio.h>
#include "DemoH264Interface.h"
int main(int argc, char* argv[])
{
// Init
// 添加一些需要设置的rtsp服务信息，如用户名，密码 端口等，通过参数传递
void* param = NULL;
DemoH264Interface::createNew()->InitLive555(param);
// start
if( -1 == DemoH264Interface::createNew()->startLive555())
{
DBG_LIVE555_PRINT(" start live555 moudle failed!\n");
return 0;
}
//stop
DemoH264Interface::createNew()->stopLive555();
return 0;
}
完成这些操作后，我在Windows下测试是能正常预览的j结果如下：
但是在linux系统下貌似不行，出了问题，错误如下：
未找到stream，排查了几天也没查出来原因，在网上看了其他网友的的解惑，貌似说trackId不对，但是我此处ID只有一个，应该不会引起这个问题的，估计病因不在这里，
因为没有研究源码的实现，所以暂时未能定位到问题，希望有遇到的知道缘由的大侠能留言告诉我，我将万分感谢。
上面代码的完整路径可以到这里下载：live555完整代码