通过live555实现H264 RTSP直播（Windows版）

为何标明“Windows版”，因为firehood大神已经实现了linux版：通过live555实现H264 RTSP直播

相关文章：

【1】Win7（Windows 7）下用VS2013（Visual Studio 2013）编译live555

【2】RTSP协议分析

【3】windows命名管道

一.基础

live555的学习基本上都是从E:\live555\testProgs中的testOnDemandRTSPServer.cpp示例开始的，这个例子实现了一个最简单的RTSP服务器。文件名中的“OnDemand”意思是：依指令行事，也就是说只有当客户端通过URL主动访问并发送相关指令时，该RTSP服务器才会将文件流化并推送到客户端。这个例子是基于RTP单播的，关于单播可以参考：Qt调用jrtplib实现单播、多播和广播

通过testOnDemandRTSPServer.cpp可以学习一个RTSP服务器的搭建步骤。这里新建一个名为h264LiveMediaServer的Win32控制台工程，新建并添加h264LiveMediaServer.cpp，然后将testOnDemandRTSPServer.cpp拷贝到h264LiveMediaServer.cpp，接着做少量修改，只保留与H.264会话相关的部分，如下所示：

[cpp]  view plain  copy

1. #include "liveMedia.hh"  
2. #include "BasicUsageEnvironment.hh"  
3.   
4. UsageEnvironment* env;  
5.   
6. // True：后启动的客户端总是从当前第一个客户端已经播放到的位置开始播放  
7. // False：每个客户端都从头开始播放影视频文件  
8. Boolean reuseFirstSource = False;  
9.   
10. //该函数打印相关信息  
11. static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms,  
12.     char const* streamName, char const* inputFileName);   
13.   
14. int main(int argc, char** argv)   
15. {  
16.     //创建任务调度器并初始化使用环境  
17.     TaskScheduler* scheduler = BasicTaskScheduler::createNew();  
18.     env = BasicUsageEnvironment::createNew(*scheduler);  
19.   
20.     UserAuthenticationDatabase* authDB = NULL;  
21.   
22.     //创建RTSP服务器，开始监听模客户端的连接  
23.     //注意这里的端口号不是默认的554端口，因此访问URL时，需指定该端口号  
24.     RTSPServer* rtspServer = RTSPServer::createNew(*env, 8554, authDB);  
25.     if (rtspServer == NULL)   
26.     {  
27.         *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";  
28.         exit(1);  
29.     }  
30.   
31.     char const* descriptionString  
32.         = "Session streamed by \"h264LiveMediaServer\"";  
33.   
34.     //流名字，媒体名  
35.     char const* streamName = "h264ESVideoTest";  
36.     //文件名，当客户端输入的流名字为h264ESVideoTest时，实际上打开的是test.264文件。  
37.     //这里需要特别注意一点，当通过IDE运行h264LiveMediaServer时，live555推送的是项目工作目录中的视频或音频。工作目录也就是和*.vcxproj同级的目录,  
38.     //此时视频应该放在这个目录下。当双击h264LiveMediaServer.exe运行时，视频理所当然的和h264LiveMediaServer.exe放在一个目录。  
39.     char const* inputFileName = "480320.264";   
40.     //当客户点播时，要输入流名字streamName，告诉RTSP服务器点播的是哪个流。    
41.     //创建媒体会话，流名字和文件名的对应关系是通过增加子会话建立起来的。媒体会话对会话描述、会话持续时间、流名字等与会话有关的信息进行管理。    
42.     //第2个参数:媒体名、3:媒体信息、4:媒体描述    
43.     ServerMediaSession* sms= ServerMediaSession::createNew(*env, streamName, streamName,descriptionString);  
44.     //添加264子会话 这里的文件名才是真正要打开文件的名字   
45.     //H264VideoFileServerMediaSubsession类派生自FileServerMediaSubsession派生自OnDemandServerMediaSubsession    
46.     //而OnDemandServerMediaSubsession和PassiveMediaSubsession共同派生自ServerMediaSubsession    
47.     //关于读取文件之类都在这个类中实现的，如果要将点播改为直播就是要新建类继承此类然后添加新的方法    
48.     sms->addSubsession(H264VideoFileServerMediaSubsession::createNew(*env, inputFileName, reuseFirstSource));  
49.     //为rtspserver添加session   
50.     rtspServer->addServerMediaSession(sms);  
51.     //答应信息到标准输出  
52.     announceStream(rtspServer, sms, streamName, inputFileName);  
53.       
54.     //试图为RTSP-over-HTTP通道创建一个HTTP服务器.  
55.     if (rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080))   
56.     {  
57.         *env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";  
58.     }  
59.     else   
60.     {  
61.         *env << "\n(RTSP-over-HTTP tunneling is not available.)\n";  
62.     }  
63.     //进入事件循环，对套接字的读取事件和对媒体文件的延时发送操作都在这个循环中完成。   
64.     env->taskScheduler().doEventLoop();  
65.   
66.     return 0;   
67. }  
68.   
69. static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms,  
70.     char const* streamName, char const* inputFileName) {  
71.     char* url = rtspServer->rtspURL(sms);  
72.     UsageEnvironment& env = rtspServer->envir();  
73.     env << "\n\"" << streamName << "\" stream, from the file \""  
74.         << inputFileName << "\"\n";  
75.     env << "Play this stream using the URL \"" << url << "\"\n";  
76.     delete[] url;  
77. }  

如何测试可参考【1】，测试结果如下所示：

二.实现

在通过live555实现H264 RTSP直播中，博主是通过FIFO队列实现的，FIFO队列实际上是Linux下的命名管道，而Windows下也有命名管道，因此在Windows中的流程图如下所示：

关于Windows命名管道详见【3】。

这里不使用命名管道来实现，而是直接读取本地H264文件，分解成StartCode+NALU内存块，然后拷贝到Live555 Server。这样一来，就很容易改成命名管道的形式，命名管道的客户端只需读取本地H264文件，分解成StartCode（0x000001或0x00000001）+NALU内存块，并写入管道，命名管道服务器端（在Live555 Server中）读取管道数据，并拷贝到Live555 Server。

通过“基础”中的分析可以得出，想实现自定义服务器，需要将sms->addSubsession(H264VideoFileServerMediaSubsession::createNew(*env, inputFileName,reuseFirstSource))，中的H264VideoFileServerMediaSubsession替换成自己的子会话。H264VideoFileServerMediaSubsession类在其createNewStreamSource(unsigned /*clientSessionId*/, unsigned& estBitrate)函数中调用了ByteStreamFileSource::createNew(envir(), fFileName)，而frame的获取正是在ByteStreamFileSource类中的doGetNextFrame()函数中实现的。因此，这里需要继承H264VideoFileServerMediaSubsession和ByteStreamFileSource类，并重写其中的createNewStreamSource和doGetNextFrame函数。

代码如下所示：

h264LiveFramedSource.hh

[cpp]  view plain  copy

1. #ifndef _H264LIVEFRAMEDSOURCE_HH  
2. #define _H264LIVEFRAMEDSOURCE_HH  
3.   
4.   
5. #include <ByteStreamFileSource.hh>  
6.   
7.   
8. class H264LiveFramedSource : public ByteStreamFileSource  
9. {  
10. public:  
11.     static H264LiveFramedSource* createNew(UsageEnvironment& env, unsigned preferredFrameSize = 0, unsigned playTimePerFrame = 0);  
12.   
13.   
14. protected:  
15.     H264LiveFramedSource(UsageEnvironment& env, unsigned preferredFrameSize, unsigned playTimePerFrame);  
16.     ~H264LiveFramedSource();  
17.   
18.   
19. private:  
20.     //重定义虚函数  
21.     virtual void doGetNextFrame();  
22. };  
23.   
24. #endif  

h264LiveFramedSource.cpp

[cpp]  view plain  copy

1. #include "h264LiveFramedSource.hh"  
2. #include "GroupsockHelper.hh"  
3. #include "spsdecode.h"  
4.   
5. int findStartCode(unsigned char *buf, int zeros_in_startcode)  
6. {  
7.     int info;  
8.     int i;  
9.   
10.     info = 1;  
11.     for (i = 0; i < zeros_in_startcode; i++)  
12.     if (buf[i] != 0)  
13.         info = 0;  
14.   
15.     if (buf[i] != 1)  
16.         info = 0;  
17.     return info;  
18. }  
19. //此处的NALU包括StartCode  
20. int getNextNalu(FILE* inpf, unsigned char* buf)  
21. {  
22.     int pos = 0;  
23.     int startCodeFound = 0;  
24.     int info2 = 0;  
25.     int info3 = 0;  
26.   
27.     while (!feof(inpf) && (buf[pos++] = fgetc(inpf)) == 0);  
28.   
29.     while (!startCodeFound)  
30.     {  
31.         if (feof(inpf))  
32.         {  
33.             return pos - 1;  
34.         }  
35.         buf[pos++] = fgetc(inpf);  
36.         info3 = findStartCode(&buf[pos - 4], 3);  
37.         startCodeFound=(info3 == 1);  
38.         if (info3 != 1)  
39.             info2 = findStartCode(&buf[pos - 3], 2);  
40.          startCodeFound = (info2 == 1 || info3 == 1);  
41.     }  
42.     if (info2)  
43.     {  
44.         fseek(inpf, -3, SEEK_CUR);  
45.         return pos - 3;  
46.     }  
47.     if (info3)  
48.     {  
49.         fseek(inpf, -4, SEEK_CUR);  
50.         return pos - 4;  
51.     }  
52. }  
53.   
54. FILE * inpf;  
55. unsigned char* inBuf;  
56. int inLen;  
57. int nFrameRate;  
58. H264LiveFramedSource::H264LiveFramedSource(UsageEnvironment& env, unsigned preferredFrameSize, unsigned playTimePerFrame)  
59. : ByteStreamFileSource(env, 0, preferredFrameSize, playTimePerFrame)  
60. {  
61.     char *fname = "480320.264";  
62.     inpf = NULL;  
63.     inpf = fopen(fname, "rb");  
64.     inBuf = (unsigned char*)calloc(1024 * 100, sizeof(char));  
65.     inLen = 0;  
66.     inLen = getNextNalu(inpf, inBuf);  
67.     // 读取SPS帧  
68.     unsigned int nSpsLen = inLen - 4;  
69.     unsigned char *pSps = (unsigned char*)malloc(nSpsLen);  
70.     memcpy(pSps, inBuf + 4, nSpsLen);  
71.   
72.     // 解码SPS,获取视频图像宽、高信息  
73.     int width = 0, height = 0, fps = 0;  
74.   
75.     h264_decode_sps(pSps, nSpsLen, width, height, fps);  
76.   
77.     nFrameRate = 0;  
78.     if (fps)  
79.         nFrameRate = fps;  
80.     else  
81.         nFrameRate = 25;  
82. }  
83.   
84. H264LiveFramedSource* H264LiveFramedSource::createNew(UsageEnvironment& env, unsigned preferredFrameSize, unsigned playTimePerFrame)  
85. {  
86.     H264LiveFramedSource* newSource = new H264LiveFramedSource(env, preferredFrameSize, playTimePerFrame);  
87.     return newSource;  
88. }  
89.   
90. H264LiveFramedSource::~H264LiveFramedSource()  
91. {  
92.     free(inBuf);  
93.     fclose(inpf);  
94. }  
95.   
96. // This function is called when new frame data is available from the device.  
97. // We deliver this data by copying it to the 'downstream' object, using the following parameters (class members):  
98. // 'in' parameters (these should *not* be modified by this function):  
99. //     fTo: The frame data is copied to this address.  
100. //         (Note that the variable "fTo" is *not* modified.  Instead,  
101. //          the frame data is copied to the address pointed to by "fTo".)  
102. //     fMaxSize: This is the maximum number of bytes that can be copied  
103. //         (If the actual frame is larger than this, then it should  
104. //          be truncated, and "fNumTruncatedBytes" set accordingly.)  
105. // 'out' parameters (these are modified by this function):  
106. //     fFrameSize: Should be set to the delivered frame size (<= fMaxSize).  
107. //     fNumTruncatedBytes: Should be set iff the delivered frame would have been  
108. //         bigger than "fMaxSize", in which case it's set to the number of bytes  
109. //         that have been omitted.  
110. //     fPresentationTime: Should be set to the frame's presentation time  
111. //         (seconds, microseconds).  This time must be aligned with 'wall-clock time' - i.e., the time that you would get  
112. //         by calling "gettimeofday()".  
113. //     fDurationInMicroseconds: Should be set to the frame's duration, if known.  
114. //         If, however, the device is a 'live source' (e.g., encoded from a camera or microphone), then we probably don't need  
115. //         to set this variable, because - in this case - data will never arrive 'early'.  
116. void H264LiveFramedSource::doGetNextFrame()  
117. {  
118.     fFrameSize = inLen;  
119.     if (fFrameSize > fMaxSize)  
120.     {  
121.         fNumTruncatedBytes = fFrameSize - fMaxSize;  
122.         fFrameSize = fMaxSize;  
123.     }  
124.     else  
125.     {  
126.         fNumTruncatedBytes = 0;  
127.     }  
128.     memmove(fTo, inBuf, fFrameSize);  
129.   
130.     inLen = 0;  
131.     inLen = getNextNalu(inpf, inBuf);  
132.     gettimeofday(&fPresentationTime, NULL);//时间戳   
133.     fDurationInMicroseconds = 1000000 / nFrameRate;//控制播放速度  
134.     //表示延迟0秒后再执行afterGetting函数,也可以直接用afterGetting(this)  
135.     nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc*)FramedSource::afterGetting, this);  
136. }  

h264LiveVideoServerMediaSubssion.hh

[cpp]  view plain  copy

1. #ifndef _H264LIVEVIDEOSERVERMEDIASUBSSION_HH  
2. #define _H264LIVEVIDEOSERVERMEDIASUBSSION_HH  
3. #include "H264VideoFileServerMediaSubsession.hh"  
4.   
5. class H264LiveVideoServerMediaSubssion : public H264VideoFileServerMediaSubsession {  
6.   
7. public:  
8.     static H264LiveVideoServerMediaSubssion* createNew(UsageEnvironment& env, Boolean reuseFirstSource);  
9.   
10. protected:   
11.     H264LiveVideoServerMediaSubssion(UsageEnvironment& env, Boolean reuseFirstSource);  
12.     ~H264LiveVideoServerMediaSubssion();  
13.   
14. protected:   
15.     //重定义虚函数  
16.     FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate);  
17. };  
18.   
19. #endif  

h264LiveVideoServerMediaSubssion.cpp

[cpp]  view plain  copy

1. #include "h264LiveVideoServerMediaSubssion.hh"  
2. #include "h264LiveFramedSource.hh"  
3. #include "H264VideoStreamFramer.hh"  
4.   
5. H264LiveVideoServerMediaSubssion* H264LiveVideoServerMediaSubssion::createNew(UsageEnvironment& env, Boolean reuseFirstSource)  
6. {  
7.     return new H264LiveVideoServerMediaSubssion(env, reuseFirstSource);  
8. }  
9.   
10. H264LiveVideoServerMediaSubssion::H264LiveVideoServerMediaSubssion(UsageEnvironment& env, Boolean reuseFirstSource)  
11. : H264VideoFileServerMediaSubsession(env, 0, reuseFirstSource)  
12. {  
13.   
14. }  
15.   
16. H264LiveVideoServerMediaSubssion::~H264LiveVideoServerMediaSubssion()  
17. {  
18. }  
19.   
20. FramedSource* H264LiveVideoServerMediaSubssion::createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate)  
21. {  
22.     //estimate bitrate:估计的比特率，记得根据需求修改  
23.     estBitrate = 1000; // kbps  
24.     //创建视频源  
25.     H264LiveFramedSource* liveSource = H264LiveFramedSource::createNew(envir());  
26.     if (liveSource == NULL)  
27.     {  
28.         return NULL;  
29.     }  
30.   
31.     //为视频流创建Framer  
32.     return H264VideoStreamFramer::createNew(envir(), liveSource);  
33. }  

还需在h264LiveMediaServer.cpp中做相应的修改

[cpp]  view plain  copy

1. #include "liveMedia.hh"  
2. #include "BasicUsageEnvironment.hh"  
3. #include "h264LiveVideoServerMediaSubssion.hh"  
4.   
5. UsageEnvironment* env;  
6.   
7. // True：后启动的客户端总是从当前第一个客户端已经播放到的位置开始播放  
8. // False：每个客户端都从头开始播放影视频文件  
9. Boolean reuseFirstSource = True;  
10.   
11. //该函数打印相关信息  
12. static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms, char const* streamName);   
13.   
14. int main(int argc, char** argv)   
15. {  
16.     //创建任务调度器并初始化使用环境  
17.     TaskScheduler* scheduler = BasicTaskScheduler::createNew();  
18.     env = BasicUsageEnvironment::createNew(*scheduler);  
19.     UserAuthenticationDatabase* authDB = NULL;  
20.   
21.     //创建RTSP服务器，开始监听模客户端的连接  
22.     //注意这里的端口号不是默认的554端口，因此访问URL时，需指定该端口号  
23.     RTSPServer* rtspServer = RTSPServer::createNew(*env, 8554, authDB);  
24.     if (rtspServer == NULL)   
25.     {  
26.         *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";  
27.         exit(1);  
28.     }  
29.   
30.     char const* descriptionString = "Session streamed by \"h264LiveMediaServer\"";  
31.   
32.     //流名字，媒体名  
33.     char const* streamName = "h264ESVideoTest";  
34.   
35.     //当客户点播时，要输入流名字streamName，告诉RTSP服务器点播的是哪个流。    
36.     //创建媒体会话，流名字和文件名的对应关系是通过增加子会话建立起来的。媒体会话对会话描述、会话持续时间、流名字等与会话有关的信息进行管理。    
37.     //第2个参数:媒体名、3:媒体信息、4:媒体描述    
38.     ServerMediaSession* sms= ServerMediaSession::createNew(*env, streamName, streamName ,descriptionString);  
39.   
40.     //修改为自己实现的H264LiveVideoServerMediaSubssion  
41.     sms->addSubsession(H264LiveVideoServerMediaSubssion::createNew(*env, reuseFirstSource));  
42.   
43.     //为rtspserver添加session   
44.     rtspServer->addServerMediaSession(sms);  
45.   
46.     //答应信息到标准输出  
47.     announceStream(rtspServer, sms, streamName);  
48.       
49.     //进入事件循环，对套接字的读取事件和对媒体文件的延时发送操作都在这个循环中完成。   
50.     env->taskScheduler().doEventLoop();  
51.   
52.     return 0;   
53. }  
54.   
55. static void announceStream(RTSPServer* rtspServer, ServerMediaSession* sms,char const* streamName)   
56. {  
57.     char* url = rtspServer->rtspURL(sms);  
58.     UsageEnvironment& env = rtspServer->envir();  
59.     env << "\n\"" << streamName << "\" stream\"\n";  
60.     env << "Play this stream using the URL \"" << url << "\"\n";  
61.     delete[] url;  
62. }  

关于spsdecode.h，详见： H.264（H264）解码SPS获取分辨率和帧率

三.测试

参考链接：http://blog.csdn.net/firehood_/article/details/16844397

注意* 编译时与live555的四个库会发生冲突，在项目中右键-》 链接器-》输入的附加依赖项 中添加 ws2_32.lib