通过live555实现H264 RTSP直播

布满荆棘的人生 2022-06-12 03:49 341阅读 0赞

前面的文章中介绍了《[H264视频通过RTMP流直播][H264_RTMP]》，下面将介绍一下如何将H264实时视频通过RTSP直播。

实现思路是将视频流发送给live555, 由live555来实现H264数据流直播。

视频采集模块通过FIFO队列将H264数据帧发送给live555. live555 在收到客户端的RTSP播放请求后，开始从FIFO中读取H264视频数据并通过RTSP直播出去。整个流程如下图所示：

![Center][]

**调整和修改Live555 MediaServer**

下载live555源码，在media目录下增加四个文件并修改文件live555MediaServer.cpp。增加的四个文件如下：

WW\_H264VideoServerMediaSubsession.h

WW\_H264VideoServerMediaSubsession.cpp

WW\_H264VideoSource.h

WW\_H264VideoSource.cpp

下面附上四个文件的源码：

WW\_H264VideoServerMediaSubsession.h

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#pragma once  
2.    
3.  \#include "liveMedia.hh"  
4.  \#include "BasicUsageEnvironment.hh"  
5.  \#include "GroupsockHelper.hh"  
6.    
7.  \#include "OnDemandServerMediaSubsession.hh"  
8.  \#include "WW\_H264VideoSource.h"  
9.    
10. **class** WW\_H264VideoServerMediaSubsession : **public** OnDemandServerMediaSubsession  
11. \{  
12. **public**:  
13.     WW\_H264VideoServerMediaSubsession(UsageEnvironment & env, FramedSource \* source);  
14.     ~WW\_H264VideoServerMediaSubsession(**void**);  
15.   
16. **public**:  
17.     **virtual** **char** **const** \* getAuxSDPLine(RTPSink \* rtpSink, FramedSource \* inputSource);  
18.     **virtual** FramedSource \* createNewStreamSource(unsigned clientSessionId, unsigned & estBitrate); // "estBitrate" is the stream's estimated bitrate, in kbps  
19.     **virtual** RTPSink \* createNewRTPSink(Groupsock \* rtpGroupsock, unsigned **char** rtpPayloadTypeIfDynamic, FramedSource \* inputSource);  
20.   
21.     **static** WW\_H264VideoServerMediaSubsession \* createNew(UsageEnvironment & env, FramedSource \* source);  
22.   
23.     **static** **void** afterPlayingDummy(**void** \* ptr);  
24.   
25.     **static** **void** chkForAuxSDPLine(**void** \* ptr);  
26.     **void** chkForAuxSDPLine1();  
27.   
28. **private**:  
29.     FramedSource \* m\_pSource;  
30.     **char** \* m\_pSDPLine;  
31.     RTPSink \* m\_pDummyRTPSink;  
32.     **char** m\_done;  
33. \};

WW\_H264VideoServerMediaSubsession.cpp

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include "WW\_H264VideoServerMediaSubsession.h"  
2.    
3.  WW\_H264VideoServerMediaSubsession::WW\_H264VideoServerMediaSubsession(UsageEnvironment & env, FramedSource \* source) : OnDemandServerMediaSubsession(env, True)  
4.  \{  
5.      m\_pSource = source;  
6.      m\_pSDPLine = 0;  
7.  \}  
8.    
9.  WW\_H264VideoServerMediaSubsession::~WW\_H264VideoServerMediaSubsession(**void**)  
10. \{  
11.     **if** (m\_pSDPLine)  
12.     \{  
13.         free(m\_pSDPLine);  
14.     \}  
15. \}  
16.   
17. WW\_H264VideoServerMediaSubsession \* WW\_H264VideoServerMediaSubsession::createNew(UsageEnvironment & env, FramedSource \* source)  
18. \{  
19.     **return** **new** WW\_H264VideoServerMediaSubsession(env, source);  
20. \}  
21.   
22. FramedSource \* WW\_H264VideoServerMediaSubsession::createNewStreamSource(unsigned clientSessionId, unsigned & estBitrate)  
23. \{  
24.     **return** H264VideoStreamFramer::createNew(envir(), **new** WW\_H264VideoSource(envir()));  
25. \}  
26.   
27. RTPSink \* WW\_H264VideoServerMediaSubsession::createNewRTPSink(Groupsock \* rtpGroupsock, unsigned **char** rtpPayloadTypeIfDynamic, FramedSource \* inputSource)  
28. \{  
29.     **return** H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);  
30. \}  
31.   
32. **char** **const** \* WW\_H264VideoServerMediaSubsession::getAuxSDPLine(RTPSink \* rtpSink, FramedSource \* inputSource)  
33. \{  
34.     **if** (m\_pSDPLine)  
35.     \{  
36.         **return** m\_pSDPLine;  
37.     \}  
38.   
39.     m\_pDummyRTPSink = rtpSink;  
40.   
41.     //mp\_dummy\_rtpsink->startPlaying(\*source, afterPlayingDummy, this);  
42.     m\_pDummyRTPSink->startPlaying(\*inputSource, 0, 0);  
43.   
44.     chkForAuxSDPLine(**this**);  
45.   
46.     m\_done = 0;  
47.   
48.     envir().taskScheduler().doEventLoop(&m\_done);  
49.   
50.     m\_pSDPLine = strdup(m\_pDummyRTPSink->auxSDPLine());  
51.   
52.     m\_pDummyRTPSink->stopPlaying();  
53.   
54.     **return** m\_pSDPLine;  
55. \}  
56.   
57. **void** WW\_H264VideoServerMediaSubsession::afterPlayingDummy(**void** \* ptr)  
58. \{  
59.     WW\_H264VideoServerMediaSubsession \* This = (WW\_H264VideoServerMediaSubsession \*)ptr;  
60.   
61.     This->m\_done = 0xff;  
62. \}  
63.   
64. **void** WW\_H264VideoServerMediaSubsession::chkForAuxSDPLine(**void** \* ptr)  
65. \{  
66.     WW\_H264VideoServerMediaSubsession \* This = (WW\_H264VideoServerMediaSubsession \*)ptr;  
67.   
68.     This->chkForAuxSDPLine1();  
69. \}  
70.   
71. **void** WW\_H264VideoServerMediaSubsession::chkForAuxSDPLine1()  
72. \{  
73.     **if** (m\_pDummyRTPSink->auxSDPLine())  
74.     \{  
75.         m\_done = 0xff;  
76.     \}  
77.     **else**  
78.     \{  
79.         **double** delay = 1000.0 / (FRAME\_PER\_SEC);  // ms  
80.         **int** to\_delay = delay \* 1000;  // us  
81.   
82.         nextTask() = envir().taskScheduler().scheduleDelayedTask(to\_delay, chkForAuxSDPLine, **this**);  
83.     \}  
84. \}

WW\_H264VideoSource.h

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#ifndef \_WW\_H264VideoSource\_H  
2.  \#define \_WW\_H264VideoSource\_H  
3.    
4.  \#include "liveMedia.hh"  
5.  \#include "BasicUsageEnvironment.hh"  
6.  \#include "GroupsockHelper.hh"  
7.  \#include "FramedSource.hh"  
8.    
9.  \#define FRAME\_PER\_SEC 25  
10.   
11. **class** WW\_H264VideoSource : **public** FramedSource  
12. \{  
13. **public**:  
14.     WW\_H264VideoSource(UsageEnvironment & env);  
15.     ~WW\_H264VideoSource(**void**);  
16.   
17. **public**:  
18.     **virtual** **void** doGetNextFrame();  
19.     **virtual** unsigned **int** maxFrameSize() **const**;  
20.   
21.     **static** **void** getNextFrame(**void** \* ptr);  
22.     **void** GetFrameData();  
23.   
24. **private**:  
25.     **void** \*m\_pToken;  
26.     **char** \*m\_pFrameBuffer;  
27.     **int**  m\_hFifo;  
28. \};  
29.   
30. \#endif

WW\_H264VideoSource.cpp

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include "WW\_H264VideoSource.h"  
2.  \#include <stdio.h>  
3.  \#ifdef WIN32  
4.  \#include <windows.h>  
5.  \#else  
6.  \#include <sys/types.h>  
7.  \#include <sys/stat.h>  
8.  \#include <string.h>  
9.  \#include <fcntl.h>  
10. \#include <unistd.h>  
11. \#include <limits.h>  
12. \#endif  
13.   
14. \#define FIFO\_NAME     "/tmp/H264\_fifo"  
15. \#define BUFFER\_SIZE   PIPE\_BUF  
16. \#define REV\_BUF\_SIZE  (1024\*1024)  
17.   
18. \#ifdef WIN32  
19. \#define mSleep(ms)    Sleep(ms)  
20. \#else  
21. \#define mSleep(ms)    usleep(ms\*1000)  
22. \#endif  
23.   
24.   
25. WW\_H264VideoSource::WW\_H264VideoSource(UsageEnvironment & env) :   
26. FramedSource(env),  
27. m\_pToken(0),  
28. m\_pFrameBuffer(0),  
29. m\_hFifo(0)  
30. \{  
31.     m\_hFifo = open(FIFO\_NAME,O\_RDONLY);  
32.         printf("\[MEDIA SERVER\] open fifo result = \[%d\]\\n",m\_hFifo);  
33.     **if**(m\_hFifo == -1)  
34.     \{  
35.         **return**;  
36.     \}  
37.       
38.     m\_pFrameBuffer = **new** **char**\[REV\_BUF\_SIZE\];  
39.     **if**(m\_pFrameBuffer == NULL)  
40.     \{  
41.         printf("\[MEDIA SERVER\] error malloc data buffer failed\\n");  
42.         **return**;  
43.     \}  
44.     memset(m\_pFrameBuffer,0,REV\_BUF\_SIZE);  
45. \}  
46.   
47. WW\_H264VideoSource::~WW\_H264VideoSource(**void**)  
48. \{  
49.     **if**(m\_hFifo)  
50.     \{  
51.         ::close(m\_hFifo);  
52.     \}  
53.       
54.     envir().taskScheduler().unscheduleDelayedTask(m\_pToken);  
55.   
56.     **if**(m\_pFrameBuffer)  
57.     \{  
58.         **delete**\[\] m\_pFrameBuffer;  
59.         m\_pFrameBuffer = NULL;  
60.     \}  
61.   
62.     printf("\[MEDIA SERVER\] rtsp connection closed\\n");  
63. \}  
64.   
65. **void** WW\_H264VideoSource::doGetNextFrame()  
66. \{  
67.     // 根据 fps，计算等待时间  
68.     **double** delay = 1000.0 / (FRAME\_PER\_SEC \* 2);  // ms  
69.     **int** to\_delay = delay \* 1000;  // us  
70.   
71.     m\_pToken = envir().taskScheduler().scheduleDelayedTask(to\_delay, getNextFrame, **this**);  
72. \}  
73.   
74. unsigned **int** WW\_H264VideoSource::maxFrameSize() **const**  
75. \{  
76.     **return** 1024\*200;  
77. \}  
78.   
79. **void** WW\_H264VideoSource::getNextFrame(**void** \* ptr)  
80. \{  
81.     ((WW\_H264VideoSource \*)ptr)->GetFrameData();  
82. \}  
83.   
84. **void** WW\_H264VideoSource::GetFrameData()  
85. \{  
86.     gettimeofday(&fPresentationTime, 0);  
87.   
88.     fFrameSize = 0;  
89.   
90.     **int** len = 0;  
91.     unsigned **char** buffer\[BUFFER\_SIZE\] = \{0\};  
92.     **while**((len = read(m\_hFifo,buffer,BUFFER\_SIZE))>0)  
93.     \{  
94.         memcpy(m\_pFrameBuffer+fFrameSize,buffer,len);  
95.         fFrameSize+=len;  
96.     \}  
97.     //printf("\[MEDIA SERVER\] GetFrameData len = \[%d\],fMaxSize = \[%d\]\\n",fFrameSize,fMaxSize);  
98.   
99.     // fill frame data  
100.     memcpy(fTo,m\_pFrameBuffer,fFrameSize);  
101.   
102.     **if** (fFrameSize > fMaxSize)  
103.     \{  
104.         fNumTruncatedBytes = fFrameSize - fMaxSize;  
105.         fFrameSize = fMaxSize;  
106.     \}  
107.     **else**  
108.     \{  
109.         fNumTruncatedBytes = 0;  
110.     \}  
111.                    
112.     afterGetting(**this**);  
113. \}

**\[cpp\]**  [view plain][]   [copy][view plain]

修改live555MediaServer.cpp文件如下

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\*\*\*\*\*\*\*\*\*\* 
2.  This library is free software; you can redistribute it and/or modify it under 
3.  the terms of the GNU Lesser General Public License as published by the 
4.  Free Software Foundation; either version 2.1 of the License, or (at your 
5.  option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.) 
6.   
7.  This library is distributed in the hope that it will be useful, but WITHOUT 
8.  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
9.  FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for 
10. more details. 
11.  
12. You should have received a copy of the GNU Lesser General Public License 
13. along with this library; if not, write to the Free Software Foundation, Inc., 
14. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA 
15. \*\*\*\*\*\*\*\*\*\*/  
16. // Copyright (c) 1996-2013, Live Networks, Inc.  All rights reserved  
17. // LIVE555 Media Server  
18. // main program  
19.   
20. \#include <BasicUsageEnvironment.hh>  
21. \#include "DynamicRTSPServer.hh"  
22. \#include "version.hh"  
23. \#include "WW\_H264VideoSource.h"  
24. \#include "WW\_H264VideoServerMediaSubsession.h"  
25.   
26. **int** main(**int** argc, **char**\*\* argv) \{  
27.     // Begin by setting up our usage environment:  
28.     TaskScheduler\* scheduler = BasicTaskScheduler::createNew();  
29.     UsageEnvironment\* env = BasicUsageEnvironment::createNew(\*scheduler);  
30.   
31.     UserAuthenticationDatabase\* authDB = NULL;  
32. \#ifdef ACCESS\_CONTROL  
33.     // To implement client access control to the RTSP server, do the following:  
34.     authDB = **new** UserAuthenticationDatabase;  
35.     authDB->addUserRecord("username1", "password1"); // replace these with real strings  
36.     // Repeat the above with each <username>, <password> that you wish to allow  
37.     // access to the server.  
38. \#endif  
39.   
40.     // Create the RTSP server:  
41.     RTSPServer\* rtspServer = RTSPServer::createNew(\*env, 554, authDB);  
42.     **if** (rtspServer == NULL) \{  
43.         \*env << "Failed to create RTSP server: " << env->getResultMsg() << "\\n";  
44.         exit(1);  
45.     \}  
46.   
47.     // Add live stream  
48.   
49.     WW\_H264VideoSource \* videoSource = 0;  
50.   
51.     ServerMediaSession \* sms = ServerMediaSession::createNew(\*env, "live", 0, "ww live test");  
52.     sms->addSubsession(WW\_H264VideoServerMediaSubsession::createNew(\*env, videoSource));  
53.     rtspServer->addServerMediaSession(sms);  
54.   
55.     **char** \* url = rtspServer->rtspURL(sms);  
56.     \*env << "using url \\"" << url << "\\"\\n";  
57.     **delete**\[\] url;  
58.   
59.     // Run loop  
60.     env->taskScheduler().doEventLoop();  
61.   
62.     rtspServer->removeServerMediaSession(sms);  
63.   
64.     Medium::close(rtspServer);  
65.   
66.     env->reclaim();  
67.   
68.     **delete** scheduler;  
69.   
70.     **return** 1;  
71. \}

**发送H264视频流的RTSPStream**

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
2.  filename:   RTSPStream.cpp 
3.  created:    2013-08-01 
4.  author:     firehood  
5.  purpose:    通过live555实现H264 RTSP直播 
6.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/   
7.  \#include "RTSPStream.h"  
8.  \#ifdef WIN32  
9.  \#else  
10. \#include <sys/types.h>  
11. \#include <sys/stat.h>  
12. \#include <string.h>  
13. \#include <fcntl.h>  
14. \#include <unistd.h>  
15. \#include <limits.h>  
16. \#include <errno.h>  
17. \#endif  
18.   
19. \#define FIFO\_NAME    "/tmp/H264\_fifo"  
20. \#define BUFFERSIZE   PIPE\_BUF  
21.   
22. CRTSPStream::CRTSPStream(**void**)  
23. \{  
24.       
25. \}  
26.   
27. CRTSPStream::~CRTSPStream(**void**)  
28. \{  
29.       
30. \}  
31.   
32. **bool** CRTSPStream::Init()  
33. \{  
34.     **if**(access(FIFO\_NAME,F\_OK) == -1)  
35.     \{  
36.         **int** res = mkfifo(FIFO\_NAME,0777);  
37.         **if**(res != 0)  
38.         \{  
39.             printf("\[RTSPStream\] Create fifo failed.\\n");  
40.             **return** **false**;  
41.         \}  
42.     \}  
43.     **return** **true**;  
44. \}  
45.   
46.   
47. **void** CRTSPStream::Uninit()  
48. \{  
49.       
50. \}  
51.   
52. **bool** CRTSPStream::SendH264File(**const** **char** \*pFileName)  
53. \{  
54.     **if**(pFileName == NULL)  
55.     \{  
56.         **return** **false**;  
57.     \}  
58.     **FILE** \*fp = fopen(pFileName, "rb");    
59.     **if**(!fp)    
60.     \{    
61.         printf("\[RTSPStream\] error:open file %s failed!",pFileName);  
62.     \}    
63.     fseek(fp, 0, SEEK\_SET);  
64.   
65.     unsigned **char** \*buffer  = **new** unsigned **char**\[FILEBUFSIZE\];  
66.     **int** pos = 0;  
67.     **while**(1)  
68.     \{  
69.         **int** readlen = fread(buffer+pos, **sizeof**(unsigned **char**), FILEBUFSIZE-pos, fp);  
70.   
71.         **if**(readlen<=0)  
72.         \{  
73.             **break**;  
74.         \}  
75.   
76.         readlen+=pos;  
77.   
78.         **int** writelen = SendH264Data(buffer,readlen);  
79.         **if**(writelen<=0)  
80.         \{  
81.             **break**;  
82.         \}  
83.         memcpy(buffer,buffer+writelen,readlen-writelen);  
84.         pos = readlen-writelen;  
85.   
86.         mSleep(25);  
87.     \}  
88.     fclose(fp);  
89.     **delete**\[\] buffer;  
90.     **return** **true**;  
91. \}  
92.   
93. // 发送H264数据帧  
94. **int** CRTSPStream::SendH264Data(**const** unsigned **char** \*data,unsigned **int** size)  
95. \{  
96.     **if**(data == NULL)  
97.     \{  
98.         **return** 0;  
99.     \}  
100.     // open pipe with non\_block mode  
101.     **int** pipe\_fd = open(FIFO\_NAME, O\_WRONLY|O\_NONBLOCK);  
102.     //printf("\[RTSPStream\] open fifo result = \[%d\]\\n",pipe\_fd);  
103.     **if**(pipe\_fd == -1)  
104.     \{  
105.         **return** 0;  
106.     \}  
107.    
108.     **int** send\_size = 0;  
109.     **int** remain\_size = size;  
110.     **while**(send\_size < size)  
111.     \{  
112.         **int** data\_len = (remain\_size<BUFFERSIZE) ? remain\_size : BUFFERSIZE;  
113.         **int** len = write(pipe\_fd,data+send\_size,data\_len);  
114.         **if**(len == -1)  
115.         \{  
116.             **static** **int** resend\_conut = 0;  
117.             **if**(errno == EAGAIN && ++resend\_conut<=3)  
118.             \{  
119.                 printf("\[RTSPStream\] write fifo error,resend..\\n");  
120.                 **continue**;  
121.             \}  
122.             resend\_conut = 0;  
123.             printf("\[RTSPStream\] write fifo error,errorcode\[%d\],send\_size\[%d\]\\n",errno,send\_size);  
124.             **break**;  
125.         \}  
126.         **else**  
127.         \{    
128.             send\_size+= len;  
129.             remain\_size-= len;  
130.         \}  
131.     \}  
132.     close(pipe\_fd);  
133.     //printf("\[RTSPStream\] SendH264Data datalen\[%d\], sendsize = \[%d\]\\n",size,send\_size);  
134.     **return** 0;  
135. \}

**[测试][Link 1]程序代码**

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include "RTSPStream.h"  
3.    
4.  **int** main(**int** argc,**char**\* argv\[\])  
5.  \{  
6.      CRTSPStream rtspSender;  
7.      **bool** bRet = rtspSender.Init();  
8.      rtspSender.SendH264File("E:\\\\测试视频\\\\test.264");  
9.      system("pause");    
10. \}

http://blog.csdn.net/firehood\_/article/details/16844397

[H264_RTMP]: http://blog.csdn.net/firehood_/article/details/8783589
[Center]: /images/20220612/5d524990538d4070aa4fc0382929d74d.png
[view plain]: http://blog.csdn.net/firehood_/article/details/16844397#
[Link 1]: http://lib.csdn.net/base/softwaretest