目前最好的，以rtmp发送264到red5服务器的代码，darkdragonking亲测可用--《到H264视频通过RTMP直播》

╰半夏微凉° 2022-08-13 16:56 166阅读 0赞

前面的文章中提到了通过RTSP（Real Time Streaming Protocol）的方式来实现视频的直播，但RTSP方式的一个弊端是如果需要支持客户端通过网页来访问，就需要在在页面中嵌入一个ActiveX控件，而ActiveX一般都需要签名才能正常使用，否则用户在使用时还需要更改浏览器设置，并且ActiveX还只支持IE内核的浏览器，Chrome、FireFox需要IE插件才能运行，因此会特别影响用户体验。而RTMP(Real Time Messaging Protocol)很好的解决了这一个问题。由于RTMP是针对FLASH的流媒体协议，视频通过RTMP直播后，只需要在WEB上嵌入一个Web Player（如Jwplayer）即可观看，而且对平台也没什么限制，还可以方便的通过手机观看。

视频通过RTMP方式发布需要一个RTMP Server(常见的有FMS、Wowza Media Server， 开源的有CRtmpServer、Red5等)，原始视频只要按照RTMP协议发送给RTMP Server就可以RTMP视频流的发布了。为了便于视频的打包发布，封装了一个RTMPStream，目前只支持发送H264的视频文件。可以直接发送H264数据帧或H264文件，RTMPStream提供的接口如下。

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

1.  **class** CRTMPStream    
2.  \{    
3.  **public**:    
4.      CRTMPStream(**void**);    
5.      ~CRTMPStream(**void**);    
6.  **public**:    
7.      // 连接到RTMP Server    
8.      **bool** Connect(**const** **char**\* url);    
9.      // 断开连接    
10.     **void** Close();    
11.     // 发送MetaData    
12.     **bool** SendMetadata(LPRTMPMetadata lpMetaData);    
13.     // 发送H264数据帧    
14.     **bool** SendH264Packet(unsigned **char** \*data,unsigned **int** size,**bool** bIsKeyFrame,unsigned **int** nTimeStamp);    
15.     // 发送H264文件    
16.     **bool** SendH264File(**const** **char** \*pFileName);    
17. //...    
18. \}

调用示例：

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

1.  \#include <stdio.h>    
2.  \#include "RTMPStream\\RTMPStream.h"    
3.      
4.  **int** main(**int** argc,**char**\* argv\[\])    
5.  \{    
6.      CRTMPStream rtmpSender;    
7.      
8.      **bool** bRet = rtmpSender.Connect("rtmp://192.168.1.104/live/test");    
9.      
10.     rtmpSender.SendH264File("E:\\\\video\\\\test.264");    
11.     
12.     rtmpSender.Close();    
13. \}

通过JwPlayer播放效果如下：

![1365582321_9718.JPG][]

最后附上RTMPStream完整的代码：

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

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
2.  filename:   RTMPStream.cpp 
3.  created:    2013-04-3 
4.  author:     firehood  
5.  purpose:    发送H264视频到RTMP Server，使用libRtmp库 
6.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/   
7.  \#include "RTMPStream.h"  
8.  \#include "SpsDecode.h"  
9.  \#ifdef WIN32    
10. \#include <windows.h>  
11. \#endif  
12.   
13. \#ifdef WIN32  
14. \#pragma comment(lib,"WS2\_32.lib")  
15. \#pragma comment(lib,"winmm.lib")  
16. \#endif  
17.   
18. **enum**  
19. \{  
20.     FLV\_CODECID\_H264 = 7,  
21. \};  
22.   
23. **int** InitSockets()    
24. \{    
25. \#ifdef WIN32    
26.     **WORD** version;    
27.     WSADATA wsaData;    
28.     version = MAKEWORD(1, 1);    
29.     **return** (WSAStartup(version, &wsaData) == 0);    
30. \#else    
31.     **return** TRUE;    
32. \#endif    
33. \}    
34.   
35. **inline** **void** CleanupSockets()    
36. \{    
37. \#ifdef WIN32    
38.     WSACleanup();    
39. \#endif    
40. \}    
41.   
42. **char** \* put\_byte( **char** \*output, uint8\_t nVal )    
43. \{    
44.     output\[0\] = nVal;    
45.     **return** output+1;    
46. \}    
47. **char** \* put\_be16(**char** \*output, uint16\_t nVal )    
48. \{    
49.     output\[1\] = nVal & 0xff;    
50.     output\[0\] = nVal >> 8;    
51.     **return** output+2;    
52. \}    
53. **char** \* put\_be24(**char** \*output,uint32\_t nVal )    
54. \{    
55.     output\[2\] = nVal & 0xff;    
56.     output\[1\] = nVal >> 8;    
57.     output\[0\] = nVal >> 16;    
58.     **return** output+3;    
59. \}    
60. **char** \* put\_be32(**char** \*output, uint32\_t nVal )    
61. \{    
62.     output\[3\] = nVal & 0xff;    
63.     output\[2\] = nVal >> 8;    
64.     output\[1\] = nVal >> 16;    
65.     output\[0\] = nVal >> 24;    
66.     **return** output+4;    
67. \}    
68. **char** \*  put\_be64( **char** \*output, uint64\_t nVal )    
69. \{    
70.     output=put\_be32( output, nVal >> 32 );    
71.     output=put\_be32( output, nVal );    
72.     **return** output;    
73. \}    
74. **char** \* put\_amf\_string( **char** \*c, **const** **char** \*str )    
75. \{    
76.     uint16\_t len = strlen( str );    
77.     c=put\_be16( c, len );    
78.     memcpy(c,str,len);    
79.     **return** c+len;    
80. \}    
81. **char** \* put\_amf\_double( **char** \*c, **double** d )    
82. \{    
83.     \*c++ = AMF\_NUMBER;  /\* type: Number \*/    
84.     \{    
85.         unsigned **char** \*ci, \*co;    
86.         ci = (unsigned **char** \*)&d;    
87.         co = (unsigned **char** \*)c;    
88.         co\[0\] = ci\[7\];    
89.         co\[1\] = ci\[6\];    
90.         co\[2\] = ci\[5\];    
91.         co\[3\] = ci\[4\];    
92.         co\[4\] = ci\[3\];    
93.         co\[5\] = ci\[2\];    
94.         co\[6\] = ci\[1\];    
95.         co\[7\] = ci\[0\];    
96.     \}    
97.     **return** c+8;    
98. \}  
99.   
100. CRTMPStream::CRTMPStream(**void**):  
101. m\_pRtmp(NULL),  
102. m\_nFileBufSize(0),  
103. m\_nCurPos(0)  
104. \{  
105.     m\_pFileBuf = **new** unsigned **char**\[FILEBUFSIZE\];  
106.     memset(m\_pFileBuf,0,FILEBUFSIZE);  
107.     InitSockets();  
108.     m\_pRtmp = RTMP\_Alloc();    
109.     RTMP\_Init(m\_pRtmp);    
110. \}  
111.   
112. CRTMPStream::~CRTMPStream(**void**)  
113. \{  
114.     Close();  
115.     WSACleanup();    
116.     **delete**\[\] m\_pFileBuf;  
117. \}  
118.   
119. **bool** CRTMPStream::Connect(**const** **char**\* url)  
120. \{  
121.     **if**(RTMP\_SetupURL(m\_pRtmp, (**char**\*)url)<0)  
122.     \{  
123.         **return** FALSE;  
124.     \}  
125.     RTMP\_EnableWrite(m\_pRtmp);  
126.     **if**(RTMP\_Connect(m\_pRtmp, NULL)<0)  
127.     \{  
128.         **return** FALSE;  
129.     \}  
130.     **if**(RTMP\_ConnectStream(m\_pRtmp,0)<0)  
131.     \{  
132.         **return** FALSE;  
133.     \}  
134.     **return** TRUE;  
135. \}  
136.   
137. **void** CRTMPStream::Close()  
138. \{  
139.     **if**(m\_pRtmp)  
140.     \{  
141.         RTMP\_Close(m\_pRtmp);  
142.         RTMP\_Free(m\_pRtmp);  
143.         m\_pRtmp = NULL;  
144.     \}  
145. \}  
146.   
147. **int** CRTMPStream::SendPacket(unsigned **int** nPacketType,unsigned **char** \*data,unsigned **int** size,unsigned **int** nTimestamp)  
148. \{  
149.     **if**(m\_pRtmp == NULL)  
150.     \{  
151.         **return** FALSE;  
152.     \}  
153.   
154.     RTMPPacket packet;  
155.     RTMPPacket\_Reset(&packet);  
156.     RTMPPacket\_Alloc(&packet,size);  
157.   
158.     packet.m\_packetType = nPacketType;  
159.     packet.m\_nChannel = 0x04;    
160.     packet.m\_headerType = RTMP\_PACKET\_SIZE\_LARGE;    
161.     packet.m\_nTimeStamp = nTimestamp;    
162.     packet.m\_nInfoField2 = m\_pRtmp->m\_stream\_id;  
163.     packet.m\_nBodySize = size;  
164.     memcpy(packet.m\_body,data,size);  
165.   
166.     **int** nRet = RTMP\_SendPacket(m\_pRtmp,&packet,0);  
167.   
168.     RTMPPacket\_Free(&packet);  
169.   
170.     **return** nRet;  
171. \}  
172.   
173. **bool** CRTMPStream::SendMetadata(LPRTMPMetadata lpMetaData)  
174. \{  
175.     **if**(lpMetaData == NULL)  
176.     \{  
177.         **return** **false**;  
178.     \}  
179.     **char** body\[1024\] = \{0\};;  
180.       
181.     **char** \* p = (**char** \*)body;    
182.     p = put\_byte(p, AMF\_STRING );  
183.     p = put\_amf\_string(p , "@setDataFrame" );  
184.   
185.     p = put\_byte( p, AMF\_STRING );  
186.     p = put\_amf\_string( p, "onMetaData" );  
187.   
188.     p = put\_byte(p, AMF\_OBJECT );    
189.     p = put\_amf\_string( p, "copyright" );    
190.     p = put\_byte(p, AMF\_STRING );    
191.     p = put\_amf\_string( p, "firehood" );    
192.   
193.     p =put\_amf\_string( p, "width");  
194.     p =put\_amf\_double( p, lpMetaData->nWidth);  
195.   
196.     p =put\_amf\_string( p, "height");  
197.     p =put\_amf\_double( p, lpMetaData->nHeight);  
198.   
199.     p =put\_amf\_string( p, "framerate" );  
200.     p =put\_amf\_double( p, lpMetaData->nFrameRate);   
201.   
202.     p =put\_amf\_string( p, "videocodecid" );  
203.     p =put\_amf\_double( p, FLV\_CODECID\_H264 );  
204.   
205.     p =put\_amf\_string( p, "" );  
206.     p =put\_byte( p, AMF\_OBJECT\_END  );  
207.   
208.     **int** index = p-body;  
209.   
210.     SendPacket(RTMP\_PACKET\_TYPE\_INFO,(unsigned **char**\*)body,p-body,0);  
211.   
212.     **int** i = 0;  
213.     body\[i++\] = 0x17; // 1:keyframe  7:AVC  
214.     body\[i++\] = 0x00; // AVC sequence header  
215.   
216.     body\[i++\] = 0x00;  
217.     body\[i++\] = 0x00;  
218.     body\[i++\] = 0x00; // fill in 0;  
219.   
220.     // AVCDecoderConfigurationRecord.  
221.     body\[i++\] = 0x01; // configurationVersion  
222.     body\[i++\] = lpMetaData->Sps\[1\]; // AVCProfileIndication  
223.     body\[i++\] = lpMetaData->Sps\[2\]; // profile\_compatibility  
224.     body\[i++\] = lpMetaData->Sps\[3\]; // AVCLevelIndication   
225.     body\[i++\] = 0xff; // lengthSizeMinusOne    
226.   
227.     // sps nums  
228.     body\[i++\] = 0xE1; //&0x1f  
229.     // sps data length  
230.     body\[i++\] = lpMetaData->nSpsLen>>8;  
231.     body\[i++\] = lpMetaData->nSpsLen&0xff;  
232.     // sps data  
233.     memcpy(&body\[i\],lpMetaData->Sps,lpMetaData->nSpsLen);  
234.     i= i+lpMetaData->nSpsLen;  
235.   
236.     // pps nums  
237.     body\[i++\] = 0x01; //&0x1f  
238.     // pps data length   
239.     body\[i++\] = lpMetaData->nPpsLen>>8;  
240.     body\[i++\] = lpMetaData->nPpsLen&0xff;  
241.     // sps data  
242.     memcpy(&body\[i\],lpMetaData->Pps,lpMetaData->nPpsLen);  
243.     i= i+lpMetaData->nPpsLen;  
244.   
245.     **return** SendPacket(RTMP\_PACKET\_TYPE\_VIDEO,(unsigned **char**\*)body,i,0);  
246.   
247. \}  
248.   
249. **bool** CRTMPStream::SendH264Packet(unsigned **char** \*data,unsigned **int** size,**bool** bIsKeyFrame,unsigned **int** nTimeStamp)  
250. \{  
251.     **if**(data == NULL && size<11)  
252.     \{  
253.         **return** **false**;  
254.     \}  
255.   
256.     unsigned **char** \*body = **new** unsigned **char**\[size+9\];  
257.   
258.     **int** i = 0;  
259.     **if**(bIsKeyFrame)  
260.     \{  
261.         body\[i++\] = 0x17;// 1:Iframe  7:AVC  
262.     \}  
263.     **else**  
264.     \{  
265.         body\[i++\] = 0x27;// 2:Pframe  7:AVC  
266.     \}  
267.     body\[i++\] = 0x01;// AVC NALU  
268.     body\[i++\] = 0x00;  
269.     body\[i++\] = 0x00;  
270.     body\[i++\] = 0x00;  
271.   
272.     // NALU size  
273.     body\[i++\] = size>>24;  
274.     body\[i++\] = size>>16;  
275.     body\[i++\] = size>>8;  
276.     body\[i++\] = size&0xff;;  
277.   
278.     // NALU data  
279.     memcpy(&body\[i\],data,size);  
280.   
281.     **bool** bRet = SendPacket(RTMP\_PACKET\_TYPE\_VIDEO,body,i+size,nTimeStamp);  
282.   
283.     **delete**\[\] body;  
284.   
285.     **return** bRet;  
286. \}  
287.   
288. **bool** CRTMPStream::SendH264File(**const** **char** \*pFileName)  
289. \{  
290.     **if**(pFileName == NULL)  
291.     \{  
292.         **return** FALSE;  
293.     \}  
294.     **FILE** \*fp = fopen(pFileName, "rb");    
295.     **if**(!fp)    
296.     \{    
297.         printf("ERROR:open file %s failed!",pFileName);  
298.     \}    
299.     fseek(fp, 0, SEEK\_SET);  
300.     m\_nFileBufSize = fread(m\_pFileBuf, **sizeof**(unsigned **char**), FILEBUFSIZE, fp);  
301.     **if**(m\_nFileBufSize >= FILEBUFSIZE)  
302.     \{  
303.         printf("warning : File size is larger than BUFSIZE\\n");  
304.     \}  
305.     fclose(fp);    
306.   
307.     RTMPMetadata metaData;  
308.     memset(&metaData,0,**sizeof**(RTMPMetadata));  
309.   
310.     NaluUnit naluUnit;  
311.     // 读取SPS帧  
312.     ReadOneNaluFromBuf(naluUnit);  
313.     metaData.nSpsLen = naluUnit.size;  
314.     memcpy(metaData.Sps,naluUnit.data,naluUnit.size);  
315.   
316.     // 读取PPS帧  
317.     ReadOneNaluFromBuf(naluUnit);  
318.     metaData.nPpsLen = naluUnit.size;  
319.     memcpy(metaData.Pps,naluUnit.data,naluUnit.size);  
320.   
321.     // 解码SPS,获取视频图像宽、高信息  
322.     **int** width = 0,height = 0;  
323.     h264\_decode\_sps(metaData.Sps,metaData.nSpsLen,width,height);  
324.     metaData.nWidth = width;  
325.     metaData.nHeight = height;  
326.     metaData.nFrameRate = 25;  
327.      
328.     // 发送MetaData  
329.     SendMetadata(&metaData);  
330.   
331.     unsigned **int** tick = 0;  
332.     **while**(ReadOneNaluFromBuf(naluUnit))  
333.     \{  
334.         **bool** bKeyframe  = (naluUnit.type == 0x05) ? TRUE : FALSE;  
335.         // 发送H264数据帧  
336.         SendH264Packet(naluUnit.data,naluUnit.size,bKeyframe,tick);  
337.         msleep(40);  
338.         tick +=40;  
339.     \}  
340.   
341.     **return** TRUE;  
342. \}  
343.   
344. **bool** CRTMPStream::ReadOneNaluFromBuf(NaluUnit &nalu)  
345. \{  
346.     **int** i = m\_nCurPos;  
347.     **while**(i<m\_nFileBufSize)  
348.     \{  
349.         **if**(m\_pFileBuf\[i++\] == 0x00 &&  
350.             m\_pFileBuf\[i++\] == 0x00 &&  
351.             m\_pFileBuf\[i++\] == 0x00 &&  
352.             m\_pFileBuf\[i++\] == 0x01  
353.             )  
354.         \{  
355.             **int** pos = i;  
356.             **while** (pos<m\_nFileBufSize)  
357.             \{  
358.                 **if**(m\_pFileBuf\[pos++\] == 0x00 &&  
359.                     m\_pFileBuf\[pos++\] == 0x00 &&  
360.                     m\_pFileBuf\[pos++\] == 0x00 &&  
361.                     m\_pFileBuf\[pos++\] == 0x01  
362.                     )  
363.                 \{  
364.                     **break**;  
365.                 \}  
366.             \}  
367.             **if**(pos == nBufferSize)  
368.             \{  
369.                 nalu.size = pos-i;    
370.             \}  
371.             **else**  
372.             \{  
373.                 nalu.size = (pos-4)-i;  
374.             \}  
375.             nalu.type = m\_pFileBuf\[i\]&0x1f;  
376.             nalu.data = &m\_pFileBuf\[i\];  
377.   
378.             m\_nCurPos = pos-4;  
379.             **return** TRUE;  
380.         \}  
381.     \}  
382.     **return** FALSE;  
383. \}

其中，在编译过程中，需要导入rtmp对应的包和头文件，这个要自己从网上搜索下，可以参考这里http://download.csdn.net/detail/zhadenianqu/7462751

附上SpsDecode.h文件：

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

1.  \#include <stdio.h>  
2.  \#include <math.h>  
3.    
4.  **UINT** Ue(**BYTE** \*pBuff, **UINT** nLen, **UINT** &nStartBit)  
5.  \{  
6.      //计算0bit的个数  
7.      **UINT** nZeroNum = 0;  
8.      **while** (nStartBit < nLen \* 8)  
9.      \{  
10.         **if** (pBuff\[nStartBit / 8\] & (0x80 >> (nStartBit % 8))) //&:按位与，%取余  
11.         \{  
12.             **break**;  
13.         \}  
14.         nZeroNum++;  
15.         nStartBit++;  
16.     \}  
17.     nStartBit ++;  
18.   
19.   
20.     //计算结果  
21.     **DWORD** dwRet = 0;  
22.     **for** (**UINT** i=0; i<nZeroNum; i++)  
23.     \{  
24.         dwRet <<= 1;  
25.         **if** (pBuff\[nStartBit / 8\] & (0x80 >> (nStartBit % 8)))  
26.         \{  
27.             dwRet += 1;  
28.         \}  
29.         nStartBit++;  
30.     \}  
31.     **return** (1 << nZeroNum) - 1 + dwRet;  
32. \}  
33.   
34.   
35. **int** Se(**BYTE** \*pBuff, **UINT** nLen, **UINT** &nStartBit)  
36. \{  
37.     **int** UeVal=Ue(pBuff,nLen,nStartBit);  
38.     **double** k=UeVal;  
39.     **int** nValue=ceil(k/2);//ceil函数：ceil函数的作用是求不小于给定实数的最小整数。ceil(2)=ceil(1.2)=cei(1.5)=2.00  
40.     **if** (UeVal % 2==0)  
41.         nValue=-nValue;  
42.     **return** nValue;  
43. \}  
44.   
45.   
46. **DWORD** u(**UINT** BitCount,**BYTE** \* buf,**UINT** &nStartBit)  
47. \{  
48.     **DWORD** dwRet = 0;  
49.     **for** (**UINT** i=0; i<BitCount; i++)  
50.     \{  
51.         dwRet <<= 1;  
52.         **if** (buf\[nStartBit / 8\] & (0x80 >> (nStartBit % 8)))  
53.         \{  
54.             dwRet += 1;  
55.         \}  
56.         nStartBit++;  
57.     \}  
58.     **return** dwRet;  
59. \}  
60.   
61.   
62. **bool** h264\_decode\_sps(**BYTE** \* buf,unsigned **int** nLen,**int** &width,**int** &height)  
63. \{  
64.     **UINT** StartBit=0;   
65.     **int** forbidden\_zero\_bit=u(1,buf,StartBit);  
66.     **int** nal\_ref\_idc=u(2,buf,StartBit);  
67.     **int** nal\_unit\_type=u(5,buf,StartBit);  
68.     **if**(nal\_unit\_type==7)  
69.     \{  
70.         **int** profile\_idc=u(8,buf,StartBit);  
71.         **int** constraint\_set0\_flag=u(1,buf,StartBit);//(buf\[1\] & 0x80)>>7;  
72.         **int** constraint\_set1\_flag=u(1,buf,StartBit);//(buf\[1\] & 0x40)>>6;  
73.         **int** constraint\_set2\_flag=u(1,buf,StartBit);//(buf\[1\] & 0x20)>>5;  
74.         **int** constraint\_set3\_flag=u(1,buf,StartBit);//(buf\[1\] & 0x10)>>4;  
75.         **int** reserved\_zero\_4bits=u(4,buf,StartBit);  
76.         **int** level\_idc=u(8,buf,StartBit);  
77.   
78.         **int** seq\_parameter\_set\_id=Ue(buf,nLen,StartBit);  
79.   
80.         **if**( profile\_idc == 100 || profile\_idc == 110 ||  
81.             profile\_idc == 122 || profile\_idc == 144 )  
82.         \{  
83.             **int** chroma\_format\_idc=Ue(buf,nLen,StartBit);  
84.             **if**( chroma\_format\_idc == 3 )  
85.                 **int** residual\_colour\_transform\_flag=u(1,buf,StartBit);  
86.             **int** bit\_depth\_luma\_minus8=Ue(buf,nLen,StartBit);  
87.             **int** bit\_depth\_chroma\_minus8=Ue(buf,nLen,StartBit);  
88.             **int** qpprime\_y\_zero\_transform\_bypass\_flag=u(1,buf,StartBit);  
89.             **int** seq\_scaling\_matrix\_present\_flag=u(1,buf,StartBit);  
90.   
91.             **int** seq\_scaling\_list\_present\_flag\[8\];  
92.             **if**( seq\_scaling\_matrix\_present\_flag )  
93.             \{  
94.                 **for**( **int** i = 0; i < 8; i++ ) \{  
95.                     seq\_scaling\_list\_present\_flag\[i\]=u(1,buf,StartBit);  
96.                 \}  
97.             \}  
98.         \}  
99.         **int** log2\_max\_frame\_num\_minus4=Ue(buf,nLen,StartBit);  
100.         **int** pic\_order\_cnt\_type=Ue(buf,nLen,StartBit);  
101.         **if**( pic\_order\_cnt\_type == 0 )  
102.             **int** log2\_max\_pic\_order\_cnt\_lsb\_minus4=Ue(buf,nLen,StartBit);  
103.         **else** **if**( pic\_order\_cnt\_type == 1 )  
104.         \{  
105.             **int** delta\_pic\_order\_always\_zero\_flag=u(1,buf,StartBit);  
106.             **int** offset\_for\_non\_ref\_pic=Se(buf,nLen,StartBit);  
107.             **int** offset\_for\_top\_to\_bottom\_field=Se(buf,nLen,StartBit);  
108.             **int** num\_ref\_frames\_in\_pic\_order\_cnt\_cycle=Ue(buf,nLen,StartBit);  
109.   
110.             **int** \*offset\_for\_ref\_frame=**new** **int**\[num\_ref\_frames\_in\_pic\_order\_cnt\_cycle\];  
111.             **for**( **int** i = 0; i < num\_ref\_frames\_in\_pic\_order\_cnt\_cycle; i++ )  
112.                 offset\_for\_ref\_frame\[i\]=Se(buf,nLen,StartBit);  
113.             **delete** \[\] offset\_for\_ref\_frame;  
114.         \}  
115.         **int** num\_ref\_frames=Ue(buf,nLen,StartBit);  
116.         **int** gaps\_in\_frame\_num\_value\_allowed\_flag=u(1,buf,StartBit);  
117.         **int** pic\_width\_in\_mbs\_minus1=Ue(buf,nLen,StartBit);  
118.         **int** pic\_height\_in\_map\_units\_minus1=Ue(buf,nLen,StartBit);  
119.   
120.         width=(pic\_width\_in\_mbs\_minus1+1)\*16;  
121.         height=(pic\_height\_in\_map\_units\_minus1+1)\*16;  
122.   
123.         **return** **true**;  
124.     \}  
125.     **else**  
126.         **return** **false**;  
127. \}  
128.

[view plain]: http://blog.csdn.net/firehood_/article/details/8783589#
[1365582321_9718.JPG]: https://img-my.csdn.net/uploads/201304/10/1365582321_9718.JPG