H264NALUParser

1. class H264NALUParser    
2. {  
3. public:  
4.     H264NALUParser(int width , int height);  
5.     H264NALUParser();  
6.     virtual ~H264NALUParser();  
7.     void SetBuffer(unsigned char * buffer,int len,int f,int nri,int type);  
8.     BOOL readOnePacket(unsigned char * buffer,int &len);  
9.     BOOL isPacketOutstanding();  
10. private:  
11.     unsigned char * m_pNaluBuffer;  // NALU数据指向的缓冲区的指针  
12.     unsigned int m_nNaluSize;       // NALU数据缓冲区的大小  
13.     unsigned char * m_pCurNaluPos;  //指向下一个数据包要读取的缓冲区指针  
14.     int m_nFrameWidth;  
15.     int m_nFrameHeight;  
16.     int m_nPacketCounts;  
17.     int m_nPacketSeqNum;  
18.     int m_nF;  
19.     int m_nNRI;  
20.     int m_nType;  
21.     enum {  
22.         STAP_A = 24,  
23.         STAP_B = 25,  
24.         MTAP16 = 26,  
25.         MTAP24 = 27,  
26.         FU_A   = 28,  
27.         FU_B   = 29  
28.     };  
29. };    
30.   
31. ////////////////// class H264NALUParser /////////////////////////////  
32. H264NALUParser::H264NALUParser(int width , int height)  
33. {  
34.     m_nFrameWidth   = width;  
35.     m_nFrameHeight  = height;  
36.     m_pNaluBuffer   = NULL;  
37.     m_nNaluSize     = 0;  
38.     m_nPacketCounts = 0;  
39.     m_nPacketSeqNum = 0;  
40.     m_nF            = 0;  
41.     m_nNRI          = 0;  
42.     m_nType         = 0;  
43. }  
44. H264NALUParser::H264NALUParser()  
45. {  
46.     m_pNaluBuffer   = NULL;  
47.     m_nNaluSize     = 0;  
48.     m_nPacketCounts = 0;  
49.     m_nPacketSeqNum = 0;  
50.     m_nF            = 0;  
51.     m_nNRI          = 0;  
52.     m_nType         = 0;  
53. }  
54. H264NALUParser::~H264NALUParser()  
55. {  
56. }  
57. void H264NALUParser::SetBuffer(unsigned char * buffer,int len,int f,int nri,int type)  
58. {  
59.     m_pNaluBuffer   = buffer;  
60.     m_nNaluSize     = len;  
61.     m_nF            = f;  
62.     m_nNRI          = nri;  
63.     m_nType         = type;  
64.     m_pCurNaluPos   = m_pNaluBuffer;  
65.     m_nPacketCounts = (m_nNaluSize + H264_MTU - 1) / H264_MTU;  
66.     m_nPacketSeqNum = 0;  
67. }  
68. BOOL H264NALUParser::readOnePacket(unsigned char * buffer,int &len)  
69. {  
70.     if(m_pCurNaluPos >= m_pNaluBuffer + m_nNaluSize)  
71.     {  
72.         return FALSE;  
73.     }  
74.     struct h264_rtp_hdr header;  
75.     int headersize;  
76.     unsigned char * pCurBuf = buffer;  
77.     if(m_nNaluSize <= H264_MTU)// Single NALU  
78.     {  
79.         header.SingleNALU.f     = m_nF;  
80.         header.SingleNALU.nri   = m_nNRI;  
81.         header.SingleNALU.type  = m_nType;  
82.         headersize = sizeof(header.SingleNALU);  
83.         memcpy(pCurBuf,&(header.SingleNALU),headersize);  
84.         pCurBuf += headersize;  
85.     }  
86.     else// FU-A  
87.     {  
88.         header.FU_A.f           = m_nF;  
89.         header.FU_A.nri         = m_nNRI;  
90.         header.FU_A.type_indicator  = FU_A;  
91.         if(0 == m_nPacketSeqNum)  
92.         {  
93.             header.FU_A.s       = 1;  
94.         }  
95.         else  
96.         {  
97.             header.FU_A.s       = 0;  
98.         }  
99.         if(m_nPacketSeqNum == m_nPacketCounts - 1)  
100.         {  
101.             header.FU_A.e       = 1;  
102.         }  
103.         else  
104.         {  
105.             header.FU_A.e       = 0;  
106.         }  
107.         header.FU_A.r           = 0;  
108.         header.FU_A.type_header = m_nType;  
109.         //  
110.         headersize = sizeof(header.FU_A);  
111.         memcpy(pCurBuf,&(header.FU_A),headersize);  
112.         pCurBuf += headersize;  
113.     }  
114.     if(m_nPacketSeqNum < m_nPacketCounts - 1)  
115.     {  
116.         memcpy(pCurBuf,m_pCurNaluPos,H264_MTU);  
117.         m_pCurNaluPos += H264_MTU;  
118.         len = headersize + H264_MTU;  
119.     }  
120.     else  
121.     {  
122.         int remainLen = m_nNaluSize % H264_MTU;  
123.         if(0 == remainLen)  
124.         {  
125.             remainLen = H264_MTU;  
126.         }  
127.         memcpy(pCurBuf,m_pCurNaluPos,remainLen);  
128.         m_pCurNaluPos += remainLen;  
129.         len = headersize + remainLen;  
130.     }  
131.     m_nPacketSeqNum ++;  
132.     return TRUE;  
133. }  
134. BOOL H264NALUParser::isPacketOutstanding()  
135. {  
136.     return (m_nPacketSeqNum < m_nPacketCounts);  
137. }