RTSP流媒体播放器实现

秒速五厘米 2022-08-13 16:57 216阅读 0赞

最近需要做一个RTSP流媒体播放器，研究了一下，封装了一个RTSP播放类CRTSPPlayer，解码库采用ffmpeg。由于需求比较简单，时间也有限，目前只实现了播放、停止、暂停几个基本的接口。下面是基于CRTSPPlayer类实现的简单RTSP播放器。

![1364396276_5277.JPG][]

目前视频只测试了H264格式，其它格式的视频还未做测试。播放器也支持直接打开本地视频播放，但播放的帧率和原始视频的码率不同步。目前还不清楚如何处理这个问题，希望懂这方面的大侠指教。

另外，还有一个开源的库VLC也可以用来开发流媒体播放器，它支持多种流媒体协议，如RTP、RTSP等，CodeProject上已经有牛人在VLCLib的基础上封装可更易使用的库VLCWrapper（地址：[http://www.codeproject.com/Articles/38952/VLCWrapper-A-Little-C-wrapper-Around-libvlc][http_www.codeproject.com_Articles_38952_VLCWrapper-A-Little-C-wrapper-Around-libvlc]）。用它可以很方便的开发视频播放器。

以下是CRTSPPlayer完整的代码：

头文件:

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

源文件：

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

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
2.  filename:   CRTSPPlayer.cpp  
3.  created:    2013-03-25  
4.  author:     firehood  
5.  purpose:    ffmpeg库实现的RTSP视频播放器 
6.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/   
7.  \#include "StdAfx.h"  
8.  \#include "RTSPPlayer.h"  
9.    
10. \#pragma comment(lib, "avformat.lib")  
11. \#pragma comment(lib, "avcodec.lib")  
12. \#pragma comment(lib, "swscale.lib")  
13. \#pragma comment(lib, "avutil.lib")  
14.   
15. \#define SHOW\_TITLE  
16.   
17. **const** **char**\* WcharToUtf8(**const** **wchar\_t** \*pwStr)    
18. \{    
19.     **if** (pwStr == NULL)    
20.     \{    
21.         **return** NULL;    
22.     \}    
23.   
24.     **int** len = WideCharToMultiByte(CP\_UTF8, 0, pwStr, -1, NULL, 0, NULL, NULL);    
25.     **if** (len <= 0)    
26.     \{    
27.         **return** NULL;    
28.     \}    
29.     **char** \*pStr = **new** **char**\[len\];    
30.     WideCharToMultiByte(CP\_UTF8, 0, pwStr, -1, pStr, len, NULL, NULL);    
31.     **return** pStr;    
32. \}    
33.   
34. CRTSPPlayer::CRTSPPlayer(**HWND** hWnd, LPRECT lpRect):  
35. m\_hWnd(hWnd),  
36. m\_rcWnd(\*lpRect),  
37. m\_hDecodeThread(NULL),  
38. m\_bExitDecodeThread(FALSE),  
39. m\_nFrameWidth(0),  
40. m\_nFrameHeight(0),  
41. m\_pFormatContext(NULL),  
42. m\_pCodecContext(NULL),  
43. m\_pCodec(NULL),  
44. m\_nStreamIndex(-1),  
45. m\_pFrameYUV(NULL),  
46. m\_pFrameRGB(NULL),  
47. m\_pBufRGB(NULL),  
48. m\_nPlayStatus(RTSP\_PLAYSTATUS\_NONE)  
49. \{  
50.     memset(m\_strFilePath,0,**sizeof**(m\_strFilePath));  
51. \}  
52.   
53. CRTSPPlayer::~CRTSPPlayer(**void**)  
54. \{  
55.     DecodeUninit();  
56. \}  
57.   
58. // 打开媒体文件  
59. **BOOL** CRTSPPlayer::OpenMedia(**LPCTSTR** pFileName)  
60. \{  
61.     **if**(pFileName == NULL)  
62.         **return** FALSE;  
63.     DecodeUninit();  
64.     memcpy(m\_strFilePath,pFileName,**sizeof**(m\_strFilePath));  
65.     DecodeInit(m\_strFilePath);  
66.     **return** TRUE;  
67. \}  
68.   
69. // 播放  
70. **void** CRTSPPlayer::Play()  
71. \{   
72.     **if**(GetPlayStatus() == RTSP\_PLAYSTATUS\_STOP)  
73.     \{  
74.         DecodeInit(m\_strFilePath);  
75.     \}  
76.     **BOOL** bRet = StartDecodeThread();  
77.     **if**(bRet)  
78.     \{  
79.         SetPlayStatus(RTSP\_PLAYSTATUS\_PLAYING);  
80.     \}  
81. \}  
82.   
83. // 暂停  
84. **void** CRTSPPlayer::Pause()  
85. \{  
86.     StopDecodeThread();  
87.     SetPlayStatus(RTSP\_PLAYSTATUS\_PAUSE);  
88. \}  
89.   
90. // 停止  
91. **void** CRTSPPlayer::Stop()  
92. \{  
93.     StopDecodeThread();  
94.     DecodeUninit();  
95.     SetPlayStatus(RTSP\_PLAYSTATUS\_STOP);  
96. \}  
97.   
98. **BOOL** CRTSPPlayer::StartDecodeThread()  
99. \{  
100.     **if**(m\_hDecodeThread == NULL)  
101.     \{  
102.         m\_hDecodeThread = CreateThread(NULL, 0, (LPTHREAD\_START\_ROUTINE)ThreadDecodeVideo, **this**, 0, NULL);  
103.     \}  
104.     **return** m\_hDecodeThread ? TRUE : FALSE;  
105. \}  
106.   
107. **void** CRTSPPlayer::StopDecodeThread()  
108. \{  
109.     **if**(m\_hDecodeThread)  
110.     \{  
111.         m\_bExitDecodeThread = TRUE;  
112.         WaitForSingleObject(m\_hDecodeThread,INFINITE);  
113.         CloseHandle(m\_hDecodeThread);  
114.         m\_hDecodeThread = NULL;  
115.     \}  
116. \}  
117.   
118. **int** CRTSPPlayer::ImgConvert(AVPicture \* dst, PixelFormat dst\_pix\_fmt, **const** AVPicture \* src, PixelFormat src\_pix\_fmt, **int** src\_width, **int** src\_height)  
119. \{  
120.   
121.     unsigned **char** \* srcSlice\[4\];  
122.     **int** srcStride\[4\] = \{0\};  
123.   
124.     unsigned **char** \* dstSlice\[4\];  
125.     **int** dstStride\[4\] = \{0\};  
126.   
127.   
128.     **for** (**int** i=0; i<4; i++)  
129.     \{  
130.         srcSlice\[i\] = src->data\[i\];  
131.         srcStride\[i\] = src->linesize\[i\];  
132.   
133.         dstSlice\[i\] = dst->data\[i\];  
134.         dstStride\[i\] = dst->linesize\[i\];  
135.     \}  
136.   
137.     SwsContext \*pSwsContext = sws\_getContext(src\_width, src\_height, src\_pix\_fmt, src\_width, src\_height, dst\_pix\_fmt, SWS\_BICUBIC, NULL, NULL, NULL);  
138.   
139.     **int** nRet = sws\_scale(pSwsContext, srcSlice, srcStride, 0, src\_height, dstSlice, dstStride);  
140.   
141.     **if** (pSwsContext != NULL)  
142.     \{  
143.         sws\_freeContext(pSwsContext);  
144.     \}  
145.   
146.     **return** nRet;  
147. \}  
148.   
149. **int** WINAPI CRTSPPlayer::ThreadDecodeVideo(**LPVOID** lpParam)  
150. \{  
151.     CRTSPPlayer \*pPlayer = (CRTSPPlayer\*)lpParam;  
152.   
153.     pPlayer->BeginDecode();  
154.   
155.     **return** 0;  
156. \}  
157.   
158. **int** CRTSPPlayer::DecodeInit(**LPCTSTR** pFileName)  
159. \{  
160.     **if**(pFileName == NULL)  
161.     \{  
162.         **return** -1;  
163.     \}  
164.   
165.     av\_register\_all();  
166.   
167. \#ifdef  UNICODE     
168.     **const** **char** \*filePath = WcharToUtf8(pFileName);   
169.     // Open video  
170.     **if** (av\_open\_input\_file(&m\_pFormatContext, filePath, NULL, 0, NULL) != 0)  
171.     \{  
172.         **return** -2; // Couldn't open file  
173.     \}  
174.     **delete**\[\] filePath;  
175. \#else  
176.     // Open video  
177.     **if** (av\_open\_input\_file(&m\_pFormatContext, pFileName, NULL, 0, NULL) != 0)  
178.     \{  
179.         **return** -2; // Couldn't open file  
180.     \}  
181. \#endif  
182.     // Retrieve stream information  
183.     **if** (av\_find\_stream\_info(m\_pFormatContext) < 0)  
184.     \{  
185.         **return** -3; // Couldn't find stream information  
186.     \}  
187.   
188.     // Find the first video stream  
189.     **for** (**UINT** i=0; i<m\_pFormatContext->nb\_streams; i++)  
190.     \{  
191.         **if** (m\_pFormatContext->streams\[i\]->codec->codec\_type == CODEC\_TYPE\_VIDEO)  
192.         \{  
193.             m\_nStreamIndex = i;  
194.             **break**;  
195.         \}  
196.     \}  
197.     **if** (m\_nStreamIndex == -1)  
198.     \{  
199.         **return** -4; // Didn't find a video stream  
200.     \}  
201.   
202.     // Get a pointer to the codec context for the video stream  
203.     m\_pCodecContext = m\_pFormatContext->streams\[m\_nStreamIndex\]->codec;  
204.   
205.     // Find the decoder for the video stream  
206.     m\_pCodec = avcodec\_find\_decoder(m\_pCodecContext->codec\_id);  
207.     **if** (m\_pCodec == NULL)  
208.     \{  
209.         **return** -5 ; // Codec not found  
210.     \}  
211.   
212.     // Inform the codec that we can handle truncated bitstreams -- i.e.,  
213.     // bitstreams where frame boundaries can fall in the middle of packets  
214.     **if** (m\_pCodec->capabilities & CODEC\_CAP\_TRUNCATED)  
215.     \{  
216.         m\_pCodecContext->flags |= CODEC\_FLAG\_TRUNCATED;  // we do not send complete frames  
217.     \}  
218.   
219.     // Open codec  
220.     **if** (avcodec\_open(m\_pCodecContext, m\_pCodec) < 0)  
221.     \{  
222.         **return** -6; // Could not open codec  
223.     \}  
224.   
225.     // Allocate video frame  
226.     m\_pFrameYUV = avcodec\_alloc\_frame();  
227.   
228.     // Allocate an AVFrame structure  
229.     m\_pFrameRGB = avcodec\_alloc\_frame();  
230.   
231.     // Determine required buffer size and allocate buffer  
232.     **int** numBytes = avpicture\_get\_size(PIX\_FMT\_BGR24, m\_pCodecContext->width, m\_pCodecContext->height);  
233.     m\_pBufRGB = **new** **BYTE** \[numBytes\];  
234.     memset(m\_pBufRGB,0,numBytes);  
235.     // Assign appropriate parts of buffer to image planes in m\_pFrameRGB  
236.     avpicture\_fill((AVPicture \*)m\_pFrameRGB, m\_pBufRGB, PIX\_FMT\_BGR24, m\_pCodecContext->width, m\_pCodecContext->height);  
237.   
238.     m\_nFrameWidth  = m\_pCodecContext->width;  
239.     m\_nFrameHeight = m\_pCodecContext->height;  
240.   
241.     **return** 0;  
242. \}  
243.   
244. **void** CRTSPPlayer::DecodeUninit()  
245. \{  
246.     // Close the codec  
247.     **if** (m\_pCodecContext)  
248.     \{  
249.         avcodec\_close(m\_pCodecContext);  
250.         //av\_free(m\_pCodec);  
251.         m\_pCodecContext = NULL;  
252.         m\_pCodec = NULL;  
253.     \}  
254.   
255.     // Close the video file  
256.     **if** (m\_pFormatContext)  
257.     \{  
258.         av\_close\_input\_file(m\_pFormatContext);  
259.         m\_pFormatContext = NULL;  
260.     \}  
261.   
262.     **if** (m\_pFrameYUV)  
263.     \{  
264.         av\_free(m\_pFrameYUV);  
265.         m\_pFrameYUV = NULL;  
266.     \}  
267.   
268.     **if** (m\_pFrameRGB)  
269.     \{  
270.         av\_free(m\_pFrameRGB);  
271.         m\_pFrameRGB = NULL;  
272.     \}  
273.   
274.     **if** (m\_pBufRGB)  
275.     \{  
276.         **delete** \[\] m\_pBufRGB;  
277.         m\_pBufRGB = NULL;  
278.     \}  
279. \}  
280.   
281. **int** CRTSPPlayer::BeginDecode()  
282. \{  
283.     **int** bytesRemaining = 0, bytesDecoded;  
284.     **BYTE** \* rawData = NULL;  
285.   
286.     **int** frameFinished = 0;  
287.   
288.     m\_struPacket.data = NULL;  
289.     m\_struPacket.size = 0;  
290.   
291.     m\_bExitDecodeThread = FALSE;  
292.   
293.     **while** (!m\_bExitDecodeThread && m\_pFormatContext)  
294.     \{  
295.         // Read the next packet, skipping all packets that aren't for this stream  
296.         **do**  
297.         \{  
298.             // Read new packet  
299.             **if** (av\_read\_frame(m\_pFormatContext, &m\_struPacket) < 0)  
300.             \{  
301.   
302.                 **return** -2;  
303.             \}  
304.         \} **while** (m\_struPacket.stream\_index != m\_nStreamIndex);  
305.   
306.         bytesRemaining = m\_struPacket.size;  
307.         rawData = m\_struPacket.data;  
308.   
309.         // Work on the current packet until we have decoded all of it  
310.         **while** (bytesRemaining > 0)  
311.         \{  
312.             // Decode the next chunk of data  
313.             bytesDecoded = avcodec\_decode\_video(m\_pCodecContext, m\_pFrameYUV, &frameFinished, rawData, bytesRemaining);  
314.   
315.             // Was there an error?  
316.             **if** (bytesDecoded < 0)  
317.             \{  
318.                 **return** -1;  
319.             \}  
320.   
321.             bytesRemaining -= bytesDecoded;  
322.             rawData += bytesDecoded;  
323.   
324.             // Did we finish the current frame? Then we can return  
325.             **if** (frameFinished)  
326.             \{  
327.                 ImgConvert(  
328.                     (AVPicture \*)m\_pFrameRGB,  
329.                     PIX\_FMT\_BGR24,  
330.                     (AVPicture \*)m\_pFrameYUV,  
331.                     m\_pCodecContext->pix\_fmt,  
332.                     m\_pCodecContext->width,  
333.                     m\_pCodecContext->height);  
334.   
335.                 Display();  
336.             \}  
337.         \}  
338.     \}  
339.     m\_hDecodeThread = NULL;  
340.     **return** 0;  
341. \}  
342.   
343. **void** CRTSPPlayer::Display()  
344. \{  
345.     **HDC** hdc = GetDC(m\_hWnd);  
346.     // 创建内存DC  
347.     **HDC** hMemDc = CreateCompatibleDC(hdc);       
348.   
349.     // 创建位图  
350.     BITMAPINFOHEADER bmpHdr = \{0\};    
351.     bmpHdr.biSize = **sizeof** (BITMAPINFOHEADER);    
352.     bmpHdr.biWidth = m\_nFrameWidth;    
353.     bmpHdr.biHeight = -m\_nFrameHeight;    
354.     bmpHdr.biPlanes = 1;    
355.     bmpHdr.biBitCount = 24;    
356.     bmpHdr.biCompression = BI\_RGB;    
357.   
358.     **BYTE** \*pData = NULL;     
359.     **HBITMAP** hBitmap = CreateDIBSection (NULL, (BITMAPINFO \*)&bmpHdr, DIB\_RGB\_COLORS, (**void**\*\*)&pData, NULL, 0);    
360.   
361.     **try**  
362.     \{  
363.         memcpy(pData, m\_pBufRGB, m\_nFrameWidth \* m\_nFrameHeight \* 3);  
364.     \}  
365.     **catch** (CMemoryException\* e)  
366.     \{  
367.           
368.     \}  
369.   
370.     **HBITMAP** hOldBitmap = (**HBITMAP**)SelectObject(hMemDc, hBitmap);  
371.   
372. \#ifdef SHOW\_TITLE  
373.     // 设置字体参数  
374.     LOGFONT logfont;  
375.     memset(&logfont, 0, **sizeof**(LOGFONT));  
376.     logfont.lfHeight = 40;  
377.     logfont.lfWidth = 0;      
378.     logfont.lfEscapement = 0;  
379.     logfont.lfOrientation = 0;  
380.     logfont.lfWeight = 30;  
381.     logfont.lfItalic = 0;  
382.     logfont.lfUnderline = 0;  
383.     logfont.lfStrikeOut = 0;  
384.     logfont.lfCharSet = DEFAULT\_CHARSET;     
385.     logfont.lfOutPrecision= OUT\_DEFAULT\_PRECIS;     
386.     logfont.lfClipPrecision= OUT\_DEFAULT\_PRECIS;     
387.     logfont.lfQuality = DEFAULT\_QUALITY;     
388.     logfont.lfPitchAndFamily= DEFAULT\_PITCH;    
389.   
390.     // 创建字体并选入环境  
391.     **HFONT** hFont = CreateFontIndirect(&logfont);  
392.     **HFONT** hOldFont = (**HFONT**)SelectObject(hMemDc, hFont);  
393.   
394.     // 设置绘图环境  
395.     SetBkMode(hMemDc, TRANSPARENT);    
396.     SetTextColor(hMemDc, RGB(255, 255, 0));  
397.   
398.     // 绘制文字  
399.     TextOut(hMemDc,0,0,m\_strFilePath,\_tcslen(m\_strFilePath));  
400.   
401.     // 恢复环境释放字体  
402.     SelectObject(hMemDc, hOldFont);  
403. \#endif  
404.     StretchBlt(    
405.         hdc,    
406.         m\_rcWnd.left,     
407.         m\_rcWnd.top,     
408.         m\_rcWnd.right-m\_rcWnd.left,     
409.         m\_rcWnd.bottom-m\_rcWnd.top,     
410.         hMemDc,    
411.         0,     
412.         0,     
413.         m\_nFrameWidth,     
414.         m\_nFrameHeight,     
415.         SRCCOPY);    
416.   
417.     // 恢复并释放环境      
418.     SelectObject(hMemDc,hOldBitmap);    
419.     DeleteObject(hBitmap);    
420.     DeleteDC(hMemDc);    
421. \}  
422.   
423. // 获取播放状态  
424. RTSP\_PLAYSTATUS CRTSPPlayer::GetPlayStatus(**void**)  
425. \{  
426.     **return** m\_nPlayStatus;  
427. \}  
428.   
429. // 设置播放状态  
430. **void** CRTSPPlayer::SetPlayStatus(RTSP\_PLAYSTATUS playStatus)  
431. \{  
432.     m\_nPlayStatus = playStatus;  
433. \}  
434.

[1364396276_5277.JPG]: https://img-my.csdn.net/uploads/201303/27/1364396276_5277.JPG
[http_www.codeproject.com_Articles_38952_VLCWrapper-A-Little-C-wrapper-Around-libvlc]: http://www.codeproject.com/Articles/38952/VLCWrapper-A-Little-C-wrapper-Around-libvlc
[view plain]: http://blog.csdn.net/firehood_/article/details/8727914#