基于RTP的H264视频数据打包解包类

最近考虑使用RTP替换原有的高清视频传输协议,遂上网查找有关H264视频RTP打包、解包的文档和代码。功夫不负有心人,找到不少有价值的文档和代码。参考这些资料,写了H264 RTP打包类、解包类,实现了单个NAL单元包和FU_A分片单元包。对于丢包处理,采用简单的策略:丢弃随后的所有数据包,直到收到关键帧。测试效果还不错,代码贴上来,若能为同道中人借鉴一二,足矣。两个类的使用说明如下(省略了错误处理过程):

 DWORD H264SSRC ;
 CH264_RTP_PACK pack ( H264SSRC ) ;
 BYTE *pVideoData ;
 DWORD Size, ts ;
 bool IsEndOfFrame ;
 WORD wLen ;
 pack.Set ( pVideoData, Size, ts, IsEndOfFrame ) ;
 BYTE *pPacket ;
 while ( pPacket = pack.Get ( &wLen ) )
 {
  // rtp packet process
  // ...
 }


 HRESULT hr ;
 CH264_RTP_UNPACK unpack ( hr ) ;
 BYTE *pRtpData ;
 WORD inSize;
 int outSize ;
 BYTE *pFrame = unpack.Parse_RTP_Packet ( pRtpData, inSize, &outSize ) ;
 if ( pFrame != NULL )
 {
  // frame process
  // ...
 }

 

 
view plaincopy to clipboardprint?
01.//////////////////////////////////////////////////////////////////////////////////////////  
02.// class CH264_RTP_PACK start  
03. 
04.class CH264_RTP_PACK  
05.{  
06.    #define RTP_VERSION 2  
07. 
08.    typedef struct NAL_msg_s   
09.    {  
10.        bool eoFrame ;  
11.        unsigned char type;     // NAL type  
12.        unsigned char *start;   // pointer to first location in the send buffer  
13.        unsigned char *end; // pointer to last location in send buffer  
14.        unsigned long size ;  
15.    } NAL_MSG_t;  
16. 
17.    typedef struct   
18.    {  
19.        //LITTLE_ENDIAN  
20.        unsigned short   cc:4;      /* CSRC count                 */ 
21.        unsigned short   x:1;       /* header extension flag      */ 
22.        unsigned short   p:1;       /* padding flag               */ 
23.        unsigned short   v:2;       /* packet type                */ 
24.        unsigned short   pt:7;      /* payload type               */ 
25.        unsigned short   m:1;       /* marker bit                 */ 
26. 
27.        unsigned short    seq;      /* sequence number            */ 
28.        unsigned long     ts;       /* timestamp                  */ 
29.        unsigned long     ssrc;     /* synchronization source     */ 
30.    } rtp_hdr_t;  
31. 
32.    typedef struct tagRTP_INFO  
33.    {  
34.        NAL_MSG_t   nal;        // NAL information  
35.        rtp_hdr_t   rtp_hdr;    // RTP header is assembled here  
36.        int hdr_len;            // length of RTP header  
37. 
38.        unsigned char *pRTP;    // pointer to where RTP packet has beem assembled  
39.        unsigned char *start;   // pointer to start of payload  
40.        unsigned char *end;     // pointer to end of payload  
41. 
42.        unsigned int s_bit;     // bit in the FU header  
43.        unsigned int e_bit;     // bit in the FU header  
44.        bool FU_flag;       // fragmented NAL Unit flag  
45.    } RTP_INFO;  
46. 
47.public:  
48.    CH264_RTP_PACK(unsigned long H264SSRC, unsigned char H264PAYLOADTYPE=96, unsigned short MAXRTPPACKSIZE=1472 )  
49.    {  
50.        m_MAXRTPPACKSIZE = MAXRTPPACKSIZE ;  
51.        if ( m_MAXRTPPACKSIZE > 10000 )  
52.        {  
53.            m_MAXRTPPACKSIZE = 10000 ;  
54.        }  
55.        if ( m_MAXRTPPACKSIZE < 50 )  
56.        {  
57.            m_MAXRTPPACKSIZE = 50 ;  
58.        }  
59.          
60.        memset ( &m_RTP_Info, 0, sizeof(m_RTP_Info) ) ;  
61. 
62.        m_RTP_Info.rtp_hdr.pt = H264PAYLOADTYPE ;  
63.        m_RTP_Info.rtp_hdr.ssrc = H264SSRC ;  
64.        m_RTP_Info.rtp_hdr.v = RTP_VERSION ;  
65. 
66.        m_RTP_Info.rtp_hdr.seq = 0 ;  
67.    }  
68. 
69.    ~CH264_RTP_PACK(void)  
70.    {  
71.    }  
72. 
73.    //传入Set的数据必须是一个完整的NAL,起始码为0x00000001。  
74.    //起始码之前至少预留10个字节,以避免内存COPY操作。  
75.    //打包完成后,原缓冲区内的数据被破坏。  
76.    bool Set ( unsigned char *NAL_Buf, unsigned long NAL_Size, unsigned long Time_Stamp, bool End_Of_Frame )  
77.    {  
78.        unsigned long startcode = StartCode(NAL_Buf) ;  
79.          
80.        if ( startcode != 0x01000000 )  
81.        {  
82.            return false ;  
83.        }  
84. 
85.        int type = NAL_Buf[4] & 0x1f ;  
86.        if ( type < 1 || type > 12 )  
87.        {  
88.            return false ;  
89.        }  
90. 
91.        m_RTP_Info.nal.start = NAL_Buf ;  
92.        m_RTP_Info.nal.size = NAL_Size ;  
93.        m_RTP_Info.nal.eoFrame = End_Of_Frame ;  
94.        m_RTP_Info.nal.type = m_RTP_Info.nal.start[4] ;  
95.        m_RTP_Info.nal.end = m_RTP_Info.nal.start + m_RTP_Info.nal.size ;  
96. 
97.        m_RTP_Info.rtp_hdr.ts = Time_Stamp ;  
98. 
99.        m_RTP_Info.nal.start += 4 ; // skip the syncword  
100.                                      
101.        if ( (m_RTP_Info.nal.size + 7) > m_MAXRTPPACKSIZE )  
102.        {  
103.            m_RTP_Info.FU_flag = true ;  
104.            m_RTP_Info.s_bit = 1 ;  
105.            m_RTP_Info.e_bit = 0 ;  
106. 
107.            m_RTP_Info.nal.start += 1 ; // skip NAL header  
108.        }  
109.        else 
110.        {  
111.            m_RTP_Info.FU_flag = false ;  
112.            m_RTP_Info.s_bit = m_RTP_Info.e_bit = 0 ;  
113.        }  
114.          
115.        m_RTP_Info.start = m_RTP_Info.end = m_RTP_Info.nal.start ;  
116.        m_bBeginNAL = true ;  
117. 
118.        return true ;  
119.    }  
120. 
121.    //循环调用Get获取RTP包,直到返回值为NULL  
122.    unsigned char* Get ( unsigned short *pPacketSize )  
123.    {  
124.        if ( m_RTP_Info.end == m_RTP_Info.nal.end )  
125.        {  
126.            *pPacketSize = 0 ;  
127.            return NULL ;  
128.        }  
129. 
130.        if ( m_bBeginNAL )  
131.        {  
132.            m_bBeginNAL = false ;  
133.        }  
134.        else 
135.        {  
136.            m_RTP_Info.start = m_RTP_Info.end;  // continue with the next RTP-FU packet  
137.        }  
138. 
139.        int bytesLeft = m_RTP_Info.nal.end - m_RTP_Info.start ;  
140.        int maxSize = m_MAXRTPPACKSIZE - 12 ;   // sizeof(basic rtp header) == 12 bytes  
141.        if ( m_RTP_Info.FU_flag )  
142.            maxSize -= 2 ;  
143. 
144.        if ( bytesLeft > maxSize )  
145.        {  
146.            m_RTP_Info.end = m_RTP_Info.start + maxSize ;   // limit RTP packetsize to 1472 bytes  
147.        }  
148.        else 
149.        {  
150.            m_RTP_Info.end = m_RTP_Info.start + bytesLeft ;  
151.        }  
152. 
153.        if ( m_RTP_Info.FU_flag )  
154.        {   // multiple packet NAL slice  
155.            if ( m_RTP_Info.end == m_RTP_Info.nal.end )  
156.            {  
157.                m_RTP_Info.e_bit = 1 ;  
158.            }  
159.        }  
160. 
161.        m_RTP_Info.rtp_hdr.m =  m_RTP_Info.nal.eoFrame ? 1 : 0 ; // should be set at EofFrame  
162.        if ( m_RTP_Info.FU_flag && !m_RTP_Info.e_bit )  
163.        {  
164.            m_RTP_Info.rtp_hdr.m = 0 ;  
165.        }  
166. 
167.        m_RTP_Info.rtp_hdr.seq++ ;  
168. 
169.        unsigned char *cp = m_RTP_Info.start ;  
170.        cp -= ( m_RTP_Info.FU_flag ? 14 : 12 ) ;  
171.        m_RTP_Info.pRTP = cp ;  
172.          
173.        unsigned char *cp2 = (unsigned char *)&m_RTP_Info.rtp_hdr ;  
174.        cp[0] = cp2[0] ;  
175.        cp[1] = cp2[1] ;  
176. 
177.        cp[2] = ( m_RTP_Info.rtp_hdr.seq >> 8 ) & 0xff ;  
178.        cp[3] = m_RTP_Info.rtp_hdr.seq & 0xff ;  
179. 
180.        cp[4] = ( m_RTP_Info.rtp_hdr.ts >> 24 ) & 0xff ;  
181.        cp[5] = ( m_RTP_Info.rtp_hdr.ts >> 16 ) & 0xff ;  
182.        cp[6] = ( m_RTP_Info.rtp_hdr.ts >>  8 ) & 0xff ;  
183.        cp[7] = m_RTP_Info.rtp_hdr.ts & 0xff ;  
184. 
185.        cp[8] =  ( m_RTP_Info.rtp_hdr.ssrc >> 24 ) & 0xff ;  
186.        cp[9] =  ( m_RTP_Info.rtp_hdr.ssrc >> 16 ) & 0xff ;  
187.        cp[10] = ( m_RTP_Info.rtp_hdr.ssrc >>  8 ) & 0xff ;  
188.        cp[11] = m_RTP_Info.rtp_hdr.ssrc & 0xff ;  
189.        m_RTP_Info.hdr_len = 12 ;  
190.        /*! 
191.        * /n The FU indicator octet has the following format: 
192.        * /n 
193.        * /n      +---------------+ 
194.        * /n MSB  |0|1|2|3|4|5|6|7|  LSB 
195.        * /n      +-+-+-+-+-+-+-+-+ 
196.        * /n      |F|NRI|  Type   | 
197.        * /n      +---------------+ 
198.        * /n 
199.        * /n The FU header has the following format: 
200.        * /n 
201.        * /n      +---------------+ 
202.        * /n      |0|1|2|3|4|5|6|7| 
203.        * /n      +-+-+-+-+-+-+-+-+ 
204.        * /n      |S|E|R|  Type   | 
205.        * /n      +---------------+ 
206.        */ 
207.        if ( m_RTP_Info.FU_flag )  
208.        {  
209.            // FU indicator  F|NRI|Type  
210.            cp[12] = ( m_RTP_Info.nal.type & 0xe0 ) | 28 ;  //Type is 28 for FU_A  
211.            //FU header     S|E|R|Type  
212.            cp[13] = ( m_RTP_Info.s_bit << 7 ) | ( m_RTP_Info.e_bit << 6 ) | ( m_RTP_Info.nal.type & 0x1f ) ; //R = 0, must be ignored by receiver  
213. 
214.            m_RTP_Info.s_bit = m_RTP_Info.e_bit= 0 ;  
215.            m_RTP_Info.hdr_len = 14 ;  
216.        }  
217.        m_RTP_Info.start = &cp[m_RTP_Info.hdr_len] ;    // new start of payload  
218. 
219.        *pPacketSize = m_RTP_Info.hdr_len + ( m_RTP_Info.end - m_RTP_Info.start ) ;  
220.        return m_RTP_Info.pRTP ;  
221.    }  
222. 
223.private:  
224.    unsigned int StartCode( unsigned char *cp )  
225.    {  
226.        unsigned int d32 ;  
227.        d32 = cp[3] ;  
228.        d32 <<= 8 ;  
229.        d32 |= cp[2] ;  
230.        d32 <<= 8 ;  
231.        d32 |= cp[1] ;  
232.        d32 <<= 8 ;  
233.        d32 |= cp[0] ;  
234.        return d32 ;  
235.    }  
236. 
237.private:  
238.    RTP_INFO m_RTP_Info ;  
239.    bool m_bBeginNAL ;  
240.    unsigned short m_MAXRTPPACKSIZE ;  
241.};  
242. 
243.// class CH264_RTP_PACK end  
244.//////////////////////////////////////////////////////////////////////////////////////////  
245. 
246. 
247.//////////////////////////////////////////////////////////////////////////////////////////  
248.// class CH264_RTP_UNPACK start  
249. 
250.class CH264_RTP_UNPACK  
251.{  
252. 
253.#define RTP_VERSION 2  
254.#define BUF_SIZE (1024 * 500)  
255. 
256.    typedef struct   
257.    {  
258.        //LITTLE_ENDIAN  
259.        unsigned short   cc:4;      /* CSRC count                 */ 
260.        unsigned short   x:1;       /* header extension flag      */ 
261.        unsigned short   p:1;       /* padding flag               */ 
262.        unsigned short   v:2;       /* packet type                */ 
263.        unsigned short   pt:7;      /* payload type               */ 
264.        unsigned short   m:1;       /* marker bit                 */ 
265. 
266.        unsigned short    seq;      /* sequence number            */ 
267.        unsigned long     ts;       /* timestamp                  */ 
268.        unsigned long     ssrc;     /* synchronization source     */ 
269.    } rtp_hdr_t;  
270.public:  
271. 
272.    CH264_RTP_UNPACK ( HRESULT &hr, unsigned char H264PAYLOADTYPE = 96 )  
273.        : m_bSPSFound(false)  
274.        , m_bWaitKeyFrame(true)  
275.        , m_bPrevFrameEnd(false)  
276.        , m_bAssemblingFrame(false)  
277.        , m_wSeq(1234)  
278.        , m_ssrc(0)  
279.    {  
280.        m_pBuf = new BYTE[BUF_SIZE] ;  
281.        if ( m_pBuf == NULL )  
282.        {  
283.            hr = E_OUTOFMEMORY ;  
284.            return ;  
285.        }  
286. 
287.        m_H264PAYLOADTYPE = H264PAYLOADTYPE ;  
288.        m_pEnd = m_pBuf + BUF_SIZE ;  
289.        m_pStart = m_pBuf ;  
290.        m_dwSize = 0 ;  
291.        hr = S_OK ;  
292.    }  
293. 
294.    ~CH264_RTP_UNPACK(void)  
295.    {  
296.        delete [] m_pBuf ;  
297.    }  
298. 
299.    //pBuf为H264 RTP视频数据包,nSize为RTP视频数据包字节长度,outSize为输出视频数据帧字节长度。  
300.    //返回值为指向视频数据帧的指针。输入数据可能被破坏。  
301.    BYTE* Parse_RTP_Packet ( BYTE *pBuf, unsigned short nSize, int *outSize )  
302.    {  
303.        if ( nSize <= 12 )  
304.        {  
305.            return NULL ;  
306.        }  
307. 
308.        BYTE *cp = (BYTE*)&m_RTP_Header ;  
309.        cp[0] = pBuf[0] ;  
310.        cp[1] = pBuf[1] ;  
311. 
312.        m_RTP_Header.seq = pBuf[2] ;  
313.        m_RTP_Header.seq <<= 8 ;  
314.        m_RTP_Header.seq |= pBuf[3] ;  
315. 
316.        m_RTP_Header.ts = pBuf[4] ;  
317.        m_RTP_Header.ts <<= 8 ;  
318.        m_RTP_Header.ts |= pBuf[5] ;  
319.        m_RTP_Header.ts <<= 8 ;  
320.        m_RTP_Header.ts |= pBuf[6] ;  
321.        m_RTP_Header.ts <<= 8 ;  
322.        m_RTP_Header.ts |= pBuf[7] ;  
323. 
324.        m_RTP_Header.ssrc = pBuf[8] ;  
325.        m_RTP_Header.ssrc <<= 8 ;  
326.        m_RTP_Header.ssrc |= pBuf[9] ;  
327.        m_RTP_Header.ssrc <<= 8 ;  
328.        m_RTP_Header.ssrc |= pBuf[10] ;  
329.        m_RTP_Header.ssrc <<= 8 ;  
330.        m_RTP_Header.ssrc |= pBuf[11] ;  
331. 
332.        BYTE *pPayload = pBuf + 12 ;  
333.        DWORD PayloadSize = nSize - 12 ;  
334. 
335.        // Check the RTP version number (it should be 2):  
336.        if ( m_RTP_Header.v != RTP_VERSION )  
337.        {  
338.            return NULL ;  
339.        }  
340. 
341.        /* 
342.        // Skip over any CSRC identifiers in the header: 
343.        if ( m_RTP_Header.cc ) 
344.        { 
345.            long cc = m_RTP_Header.cc * 4 ; 
346.            if ( Size < cc ) 
347.            { 
348.                return NULL ; 
349.            } 
350.
351.            Size -= cc ; 
352.            p += cc ; 
353.        } 
354.
355.        // Check for (& ignore) any RTP header extension 
356.        if ( m_RTP_Header.x ) 
357.        { 
358.            if ( Size < 4 ) 
359.            { 
360.                return NULL ; 
361.            } 
362.
363.            Size -= 4 ; 
364.            p += 2 ; 
365.            long l = p[0] ; 
366.            l <<= 8 ; 
367.            l |= p[1] ; 
368.            p += 2 ; 
369.            l *= 4 ; 
370.            if ( Size < l ) ; 
371.            { 
372.                return NULL ; 
373.            } 
374.            Size -= l ; 
375.            p += l ; 
376.        } 
377.         
378.        // Discard any padding bytes: 
379.        if ( m_RTP_Header.p ) 
380.        { 
381.            if ( Size == 0 ) 
382.            { 
383.                return NULL ; 
384.            } 
385.            long Padding = p[Size-1] ; 
386.            if ( Size < Padding ) 
387.            { 
388.                return NULL ; 
389.            } 
390.            Size -= Padding ; 
391.        }*/ 
392. 
393.        // Check the Payload Type.  
394.        if ( m_RTP_Header.pt != m_H264PAYLOADTYPE )  
395.        {  
396.            return NULL ;  
397.        }  
398. 
399.        int PayloadType = pPayload[0] & 0x1f ;  
400.        int NALType = PayloadType ;  
401.        if ( NALType == 28 ) // FU_A  
402.        {  
403.            if ( PayloadSize < 2 )  
404.            {  
405.                return NULL ;  
406.            }  
407. 
408.            NALType = pPayload[1] & 0x1f ;  
409.        }  
410. 
411.        if ( m_ssrc != m_RTP_Header.ssrc )  
412.        {  
413.            m_ssrc = m_RTP_Header.ssrc ;  
414.            SetLostPacket () ;  
415.        }  
416.      
417.        if ( NALType == 0x07 ) // SPS  
418.        {  
419.            m_bSPSFound = true ;  
420.        }  
421. 
422.        if ( !m_bSPSFound )  
423.        {  
424.            return NULL ;  
425.        }  
426. 
427.        if ( NALType == 0x07 || NALType == 0x08 ) // SPS PPS  
428.        {  
429.            m_wSeq = m_RTP_Header.seq ;  
430.            m_bPrevFrameEnd = true ;  
431. 
432.            pPayload -= 4 ;  
433.            *((DWORD*)(pPayload)) = 0x01000000 ;  
434.            *outSize = PayloadSize + 4 ;  
435.            return pPayload ;  
436.        }  
437. 
438.        if ( m_bWaitKeyFrame )  
439.        {  
440.            if ( m_RTP_Header.m ) // frame end  
441.            {  
442.                m_bPrevFrameEnd = true ;  
443.                if ( !m_bAssemblingFrame )  
444.                {  
445.                    m_wSeq = m_RTP_Header.seq ;  
446.                    return NULL ;  
447.                }  
448.            }  
449. 
450.            if ( !m_bPrevFrameEnd )  
451.            {  
452.                m_wSeq = m_RTP_Header.seq ;  
453.                return NULL ;  
454.            }  
455.            else 
456.            {  
457.                if ( NALType != 0x05 ) // KEY FRAME  
458.                {  
459.                    m_wSeq = m_RTP_Header.seq ;  
460.                    m_bPrevFrameEnd = false ;  
461.                    return NULL ;  
462.                }  
463.            }  
464.        }  
465. 
466. 
467.///////////////////////////////////////////////////////////////  
468.              
469.        if ( m_RTP_Header.seq != (WORD)( m_wSeq + 1 ) ) // lost packet  
470.        {  
471.            m_wSeq = m_RTP_Header.seq ;  
472.            SetLostPacket () ;            
473.            return NULL ;  
474.        }  
475.        else 
476.        {  
477.            // 码流正常  
478. 
479.            m_wSeq = m_RTP_Header.seq ;  
480.            m_bAssemblingFrame = true ;  
481.              
482.            if ( PayloadType != 28 ) // whole NAL  
483.            {  
484.                *((DWORD*)(m_pStart)) = 0x01000000 ;  
485.                m_pStart += 4 ;  
486.                m_dwSize += 4 ;  
487.            }  
488.            else // FU_A  
489.            {  
490.                if ( pPayload[1] & 0x80 ) // FU_A start  
491.                {  
492.                    *((DWORD*)(m_pStart)) = 0x01000000 ;  
493.                    m_pStart += 4 ;  
494.                    m_dwSize += 4 ;  
495. 
496.                    pPayload[1] = ( pPayload[0] & 0xE0 ) | NALType ;  
497.                      
498.                    pPayload += 1 ;  
499.                    PayloadSize -= 1 ;  
500.                }  
501.                else 
502.                {  
503.                    pPayload += 2 ;  
504.                    PayloadSize -= 2 ;  
505.                }  
506.            }  
507. 
508.            if ( m_pStart + PayloadSize < m_pEnd )  
509.            {  
510.                CopyMemory ( m_pStart, pPayload, PayloadSize ) ;  
511.                m_dwSize += PayloadSize ;  
512.                m_pStart += PayloadSize ;  
513.            }  
514.            else // memory overflow  
515.            {  
516.                SetLostPacket () ;  
517.                return NULL ;  
518.            }  
519. 
520.            if ( m_RTP_Header.m ) // frame end  
521.            {  
522.                *outSize = m_dwSize ;  
523. 
524.                m_pStart = m_pBuf ;  
525.                m_dwSize = 0 ;  
526. 
527.                if ( NALType == 0x05 ) // KEY FRAME  
528.                {  
529.                    m_bWaitKeyFrame = false ;  
530.                }  
531.                return m_pBuf ;  
532.            }  
533.            else 
534.            {  
535.                return NULL ;  
536.            }  
537.        }  
538.    }  
539. 
540.    void SetLostPacket()  
541.    {  
542.        m_bSPSFound = false ;  
543.        m_bWaitKeyFrame = true ;  
544.        m_bPrevFrameEnd = false ;  
545.        m_bAssemblingFrame = false ;  
546.        m_pStart = m_pBuf ;  
547.        m_dwSize = 0 ;  
548.    }  
549. 
550.private:  
551.    rtp_hdr_t m_RTP_Header ;  
552. 
553.    BYTE *m_pBuf ;  
554. 
555.    bool m_bSPSFound ;  
556.    bool m_bWaitKeyFrame ;  
557.    bool m_bAssemblingFrame ;  
558.    bool m_bPrevFrameEnd ;  
559.    BYTE *m_pStart ;  
560.    BYTE *m_pEnd ;  
561.    DWORD m_dwSize ;  
562. 
563.    WORD m_wSeq ;  
564. 
565.    BYTE m_H264PAYLOADTYPE ;  
566.    DWORD m_ssrc ;  
567.};  
568. 
569.// class CH264_RTP_UNPACK end  
570.////////////////////////////////////////////////////////////////////////////////////////// 

 

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/dengzikun/archive/2010/08/12/5807694.aspx

你可能感兴趣的:(struct,header,null,Class,byte,extension)