linux下面如何用ffmpeg将h264帧数据村存为FLV文件！！

wansbest

最近一段时间一直在研究怎么将接收到的H264帧数据，存为一个FLV文件，初步的想法是用ffmpeg提供的开源库来实现，但因为之前一直没接触过这个，具体怎么做还是一筹莫展，各位前辈有没有之前做过这个

的，提供一些经验呗！！！

或者不用ffmpeg，有别的方案也行，但在转换效率以及稳定性上要求很高，因为这是服务器上要做的功能，而且数据量会特别庞大。。。。。

zylthinking

靠， 这个我作过， FLV 的文件格式非常简单， 直接找 adobe 的说明， 照着写就行了

wansbest

是不是直接就拿H264的帧往flv的tag里面放，然后那些header自己根据帧的信息去构造啊！！照这么说，ffmpeg岂不根本用不到了啊！！！

hniu

授 lz 以鱼

http://wenku.baidu.com/view/f919978102d276a200292e2f.html

efolzl

一个是压缩算法，一个是存储格式。你要是只保持成文件，按格式存就是了。
不解码的话，应该不涉及ffmpeg。

zylthinking

那我也不卖渔了， 摘些代码

1. 
   
2. static char* g_lastKeyFrame = NULL;
   
3. static int g_keyfrm_buf = 0;
   
4. static int g_keyfrm_len = 0;
   
5. 
   
6. int FlvSaveKeyFrame(void* data, int len){
   
7.     if(len > g_keyfrm_buf){
   
8.         free(g_lastKeyFrame);
   
9.         g_lastKeyFrame = (char *) malloc(len);
   
10.         if(g_lastKeyFrame == NULL){
    
11.             g_keyfrm_len = 0;
    
12.             return -1;
    
13.         }
    
14.         g_keyfrm_buf = len;
    
15.     }
    
16. 
    
17.     g_keyfrm_len = len;
    
18.     if(len > 0){
    
19.         memcpy(g_lastKeyFrame, data, g_keyfrm_len);
    
20.     }
    
21.     return 0;
    
22. }
    
23. 
    
24. int FlvGetLastKeyFrame(char*& buf){
    
25.     buf = g_lastKeyFrame;
    
26.     return g_keyfrm_len;
    
27. }
    
28. 
    
29. static char* g_sps_buf = NULL;
    
30. static int g_sps_buf_len = 0;
    
31. static int g_sps_len = 0;
    
32. 
    
33. int FlvSaveSpsFrame(void* data, int len){
    
34.     if(len > g_sps_buf_len){
    
35.         free(g_sps_buf);
    
36.         g_sps_buf = (char *) malloc(len);
    
37.         if(g_sps_buf == NULL){
    
38.             g_sps_buf_len = 0;
    
39.             return -1;
    
40.         }
    
41.         g_sps_buf_len = len;
    
42.     }
    
43. 
    
44.     g_sps_len = len;
    
45.     if(len > 0){
    
46.         memcpy(g_sps_buf, data, g_sps_len);
    
47.     }
    
48.     return 0;
    
49. }
    
50. 
    
51. int FlvGetSpsFrame(char*& buf){
    
52.     buf = g_sps_buf;
    
53.     return g_sps_len;
    
54. }
    
55. 
    
56. static char* g_aac_buf = NULL;
    
57. static int g_aac_buf_len = 0;
    
58. static int g_aac_len = 0;
    
59. 
    
60. int FlvSaveAacFrame(void* data, int len){
    
61.     if(len > g_aac_buf_len){
    
62.         free(g_aac_buf);
    
63.         g_aac_buf = (char *) malloc(len);
    
64.         if(g_aac_buf == NULL){
    
65.             g_aac_buf_len = 0;
    
66.             return -1;
    
67.         }
    
68.         g_aac_buf_len = len;
    
69.     }
    
70. 
    
71.     g_aac_len = len;
    
72.     if(len > 0){
    
73.         memcpy(g_aac_buf, data, g_aac_len);
    
74.     }
    
75.     return 0;
    
76. }
    
77. 
    
78. int FlvGetAacFrame(char*& buf){
    
79.     buf = g_aac_buf;
    
80.     return g_aac_len;
    
81. }
    
82. 
    
83. typedef int (*type_parser)(const char* flv_buffer, media_info& info);
    
84. struct flv_media_parser{
    
85.     DWORD fourcc;
    
86.     type_parser parser;
    
87. };
    
88. 
    
89. //=========================================================
    
90. 
    
91. // stupid compiler
    
92. static void my_free(void* addr){
    
93.     free(addr);
    
94. }
    
95. 
    
96. static int h264_parser(const char* flv_buffer, media_info& info){
    
97.     info.bit_count = 0;
    
98.     info.extra = 1;
    
99. 
    
100.     int byte1 = ((int) flv_buffer[1]) & 0xff;
     
101.     int byte2 = ((int) flv_buffer[2]) & 0xff;
     
102.     int byte3 = ((int) flv_buffer[3]) & 0xff;
     
103.     DWORD len = (byte1 << 16) | (byte2 << 8) | byte3;
     
104. 
     
105.     int byte4 = ((int) flv_buffer[4]) & 0xff;
     
106.     int byte5 = ((int) flv_buffer[5]) & 0xff;
     
107.     int byte6 = ((int) flv_buffer[6]) & 0xff;
     
108.     int byte7 = ((int) flv_buffer[7]) & 0xff;
     
109.     int byte13 =  ((int) flv_buffer[13]) & 0xff;
     
110.     int byte14 =  ((int) flv_buffer[14]) & 0xff;
     
111.     int byte15 =  ((int) flv_buffer[15]) & 0xff;
     
112. 
     
113.     info.dts = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
     
114.     int offset = (byte13 << 16) | (byte14 << 8) | byte15;
     
115.     info.pts = info.dts + offset;
     
116. 
     
117.     int byte12 = ((int) flv_buffer[12]) & 0xff;
     
118.     if(byte12 == 0){
     
119.         int sps_len = 0;
     
120.         int pps_len = 0;
     
121.         const char* sps = NULL;
     
122.         const char* pps = NULL;
     
123. 
     
124.         int nr_sps = ((int) flv_buffer[21]) & 0x1f;
     
125.         if(nr_sps == 1){
     
126.             int byte22 = ((int) flv_buffer[22]) & 0xff;
     
127.             int byte23 = ((int) flv_buffer[23]) & 0xff;
     
128.             sps_len = (byte22 << 8) | byte23;
     
129.             sps = &flv_buffer[24];
     
130.             pps = sps + sps_len;
     
131.             sps_len += 4;
     
132.         }else{
     
133.             // no more than 1 sps currently
     
134.             assert(nr_sps == 0);
     
135.         }
     
136. 
     
137.         int nr_pps = pps[0] & 0xff;
     
138.         if(nr_pps == 1){
     
139.             int byte1 = ((int) pps[1]) & 0xff;
     
140.             int byte2 = ((int) pps[2]) & 0xff;
     
141.             pps_len = ((byte1 << 8) | byte2) + 4;
     
142.             pps = &pps[3];
     
143.         }else{
     
144.             pps = NULL;
     
145.             // no more than 1 pps currently
     
146.             assert(nr_pps == 0);
     
147.         }
     
148. 
     
149.         int header_len = sps_len + pps_len;
     
150.         assert(header_len > 0);
     
151.         unsigned char* buffer = (unsigned char *) malloc(header_len);
     
152.         if(buffer == NULL){
     
153.             return -1;
     
154.         }
     
155. 
     
156.         info.free = my_free;
     
157.         info.length = header_len;
     
158.         info.buffer = (char *) buffer;
     
159. 
     
160.         if(sps_len > 0){
     
161.             sps_len -= 4;
     
162. 
     
163.             buffer[0] = sps_len >> 24;
     
164.             buffer[1] = sps_len >> 16;
     
165.             buffer[2] = sps_len >> 8;
     
166.             buffer[3] = sps_len;
     
167.             buffer += 4;
     
168.             memcpy(buffer, sps, sps_len);
     
169.             buffer += sps_len;
     
170.         }
     
171. 
     
172.         if(pps_len > 0){
     
173.             pps_len -= 4;
     
174. 
     
175.             buffer[0] = pps_len >> 24;
     
176.             buffer[1] = pps_len >> 16;
     
177.             buffer[2] = pps_len >> 8;
     
178.             buffer[3] = pps_len;
     
179.             buffer += 4;
     
180.             memcpy(buffer, pps, pps_len);
     
181.             buffer += pps_len;
     
182.         }
     
183. 
     
184.         return len + 11 + 4;
     
185.     }else if(byte12 == 1){
     
186.         info.length = len - 5;
     
187.         info.buffer = (char *) &flv_buffer[16];
     
188.         return len + 11 + 4;
     
189.     }
     
190.     return -1;
     
191. }
     
192. 
     
193. static flv_media_parser flv_h264_parser = {
     
194.     make_fourcc('H', '2', '6', '4'),
     
195.     h264_parser
     
196. };
     
197. 
     
198. static flv_media_parser* video_parser_of(char codec_id){
     
199.     if(codec_id == (char) 0x07){
     
200.         return &flv_h264_parser;
     
201.     }
     
202.     return NULL;
     
203. }
     
204. 
     
205. static int flv_video_unpack(const char* flv_buffer, media_info& info){
     
206.     char byte11 = flv_buffer[11] & 0xff;
     
207.     BOOL key_frame = (0x10 == (byte11 & 0xf0));
     
208.     int codec_id = (byte11 & 0x0f);
     
209. 
     
210.     flv_media_parser* parser = video_parser_of(codec_id);
     
211.     if(parser == NULL){
     
212.         return -1;
     
213.     }
     
214. 
     
215.     info.fourcc = parser->fourcc;
     
216.     return parser->parser(flv_buffer, info);
     
217. }
     
218. 
     
219. //=========================================================
     
220. 
     
221. static char adts[7] = {0xff, 0xf1};
     
222. 
     
223. static int aac_parser(const char* flv_buffer, media_info& info){
     
224.     int byte1 = ((int) flv_buffer[1]) & 0xff;
     
225.     int byte2 = ((int) flv_buffer[2]) & 0xff;
     
226.     int byte3 = ((int) flv_buffer[3]) & 0xff;
     
227.     DWORD len = (byte1 << 16) | (byte2 << 8) | byte3;
     
228. 
     
229.     int byte4 = ((int) flv_buffer[4]) & 0xff;
     
230.     int byte5 = ((int) flv_buffer[5]) & 0xff;
     
231.     int byte6 = ((int) flv_buffer[6]) & 0xff;
     
232.     int byte7 = ((int) flv_buffer[7]) & 0xff;
     
233. 
     
234.     info.dts = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
     
235.     info.pts = info.dts;
     
236. 
     
237.     // flash only support 44k, 16bits aac
     
238.     info.sample_rate = 44100;
     
239.     info.bit_count = 16;
     
240.     info.chans = (flv_buffer[11] & 0x01) ? 2 : 1;
     
241.    
     
242.     int type = ((int) flv_buffer[12]) & 0xff;
     
243.     if(type == 0){
     
244.         int byte13 = ((int) flv_buffer[13]) & 0xff;
     
245.         int objType = ((byte13 & 0xf1) >> 3) - 1;
     
246. 
     
247.         int byte14 = ((int) flv_buffer[14]) & 0xff;
     
248.         int samplerate_indx = ((byte13 & 0x7) << 1 | (byte14 & 0x80) >> 7);
     
249.         int chans = (byte14 & 0x71) >> 3;
     
250.         // format of flash
     
251.         assert(chans == 2 && samplerate_indx == 7);
     
252. 
     
253.         adts[2] = (objType << 6) | (samplerate_indx << 2) | ((chans & 0x04) >> 2);
     
254.         adts[3] = ((chans & 0x03) << 6);
     
255. 
     
256.         return len + 11 + 4;
     
257.     }else if(type == 1){
     
258.         if(adts[2] == 0){
     
259.             cs << "drop audio data, because of header is missing" << endl;
     
260.             goto LABEL;
     
261.         }
     
262.         const static int adts_len = sizeof(adts);
     
263.         info.length = len - 2 + adts_len;
     
264. 
     
265.         info.buffer = (char *) malloc(info.length);
     
266.         if(info.buffer == NULL){
     
267.             return -1;
     
268.         }
     
269.         info.free = my_free;
     
270. 
     
271.         assert(sizeof(int) == 4);
     
272.         *((int *) &info.buffer[0]) = *((int *) &adts[0]);
     
273. 
     
274.         info.buffer[3] |= (info.length & 0x1fff) >> 11;
     
275.         info.buffer[4] = (info.length & 0x7ff) >> 3;
     
276.         info.buffer[5] = (info.length & 0x07) << 5;
     
277.         info.buffer[5] |= 0x1f;
     
278.         info.buffer[6] = 0xfc;
     
279.         memcpy((void *) &info.buffer[adts_len], &flv_buffer[13], len - 2);
     
280. LABEL:
     
281.         return len + 11 + 4;
     
282.     }
     
283.     return -1;
     
284. }
     
285. 
     
286. static flv_media_parser flv_aac_parser = {
     
287.     mpeg4_aac,
     
288.     aac_parser
     
289. };
     
290. 
     
291. static flv_media_parser* audio_parser_of(char codec_id){
     
292.     if(codec_id == (char) 0xa0){
     
293.         return &flv_aac_parser;
     
294.     }
     
295.     return NULL;
     
296. }
     
297. 
     
298. static int flv_audio_unpack(const char* flv_buffer, media_info& info){
     
299.     char byte11 = flv_buffer[11] & 0xff;
     
300.     char fmt = byte11 & 0xf0;
     
301. 
     
302.     flv_media_parser* parser = audio_parser_of(fmt);
     
303.     if(parser == NULL){
     
304.         return -1;
     
305.     }
     
306. 
     
307.     info.fourcc = parser->fourcc;
     
308.     return parser->parser(flv_buffer, info);
     
309. }
     
310. 
     
311. //=========================================================
     
312. 
     
313. int FlvUnpack(const char* flv_buffer, media_info& info){
     
314.     info.free = NULL;
     
315.     info.buffer = NULL;
     
316.     info.length = 0;
     
317. 
     
318.     int n = -1;
     
319.     char audio_or_video = flv_buffer[0];
     
320.     if(audio_or_video == 0x09){
     
321.         n = flv_video_unpack(flv_buffer, info);
     
322. 
     
323.         if(n != -1){
     
324.             if(FlvIsSpsFrame((BYTE *) flv_buffer, n)){
     
325.                 FlvSaveSpsFrame((void *) flv_buffer, n);
     
326.             }else if(FlvIsKeyFrame((BYTE *) flv_buffer, n)){
     
327.                 FlvSaveKeyFrame((void *) flv_buffer, n);
     
328.             }
     
329.         }
     
330.     }
     
331.    
     
332.     if(audio_or_video == 0x08){
     
333.         n = flv_audio_unpack(flv_buffer,info);
     
334.         if(n != -1){
     
335.             if(FlvIsAacHeaderFrame((BYTE *) flv_buffer, n)){
     
336.                 FlvSaveAacFrame((void *) flv_buffer, n);
     
337.             }
     
338.         }
     
339.     }
     
340. 
     
341.     return n;
     
342. }
     
343. 
     
344. BOOL FlvIsKeyFrame(BYTE* flv_buffer, int len){
     
345.     if(len < 12 || flv_buffer[0] != 0x09){
     
346.         return FALSE;
     
347.     }
     
348.         return (0x10 == (flv_buffer[11] & 0xf0));
     
349. }
     
350. 
     
351. BOOL FlvIsSpsFrame(BYTE* flv_buffer, int len){
     
352.     if(len < 13 || flv_buffer[0] != 0x09){
     
353.         return FALSE;
     
354.     }
     
355.         return (0 == (flv_buffer[12]));
     
356. }
     
357. 
     
358. BOOL FlvIsAacHeaderFrame(BYTE* flv_buffer, int len){
     
359.     if(len < 13 || flv_buffer[0] != 0x08){
     
360.         return FALSE;
     
361.     }
     
362.         return (0 == (flv_buffer[12]));
     
363. }
     
364. 
     
365. int FlvFrameLength(BYTE* flv_buffer, int len){
     
366.     if(len < 4){
     
367.         return -1;
     
368.     }
     
369. 
     
370.     int byte1 = ((int) flv_buffer[1]) & 0xff;
     
371.     int byte2 = ((int) flv_buffer[2]) & 0xff;
     
372.     int byte3 = ((int) flv_buffer[3]) & 0xff;
     
373.     int length = (byte1 << 16) | (byte2 << 8) | byte3;
     
374. 
     
375.     length += 11 + 4;
     
376.     if(length <= len){
     
377.         return length;
     
378.     }
     
379.     return -1;
     
380. }
     
381. 
     
382. DWORD FlvGetDts(BYTE* flv_buffer, int len){
     
383.     if(len < 8){
     
384.         return (DWORD) (-1);
     
385.     }
     
386.     int byte4 = ((int) flv_buffer[4]) & 0xff;
     
387.     int byte5 = ((int) flv_buffer[5]) & 0xff;
     
388.     int byte6 = ((int) flv_buffer[6]) & 0xff;
     
389.     int byte7 = ((int) flv_buffer[7]) & 0xff;
     
390. 
     
391.    DWORD st = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
     
392.    return st;
     
393. }
     
394. 
     
395. void FlvSetDts(UINT32 ts, void* buf, int len, BOOL zeroOffset){
     
396.     int left = len;
     
397.     char* pch = (char *) buf;
     
398.     while(left > 0){
     
399.         int n1 = pch[1] & 0xff;
     
400.         int n2 = pch[2] & 0xff;
     
401.         int n3 = pch[3] & 0xff;
     
402.         int n = (n1 << 16) | (n2 << 8) | n3;
     
403. 
     
404.         *((char*)pch + 4) = (unsigned char) (ts >> 16);
     
405.             *((char*)pch + 5) = (unsigned char) (ts >> 8);
     
406.             *((char*)pch + 6) = (unsigned char) ts;
     
407.             *((char*)pch + 7) = (unsigned char) (ts >> 24);
     
408. 
     
409.         if(zeroOffset){
     
410.                 *((char*)pch + 13) = 0;
     
411.                 *((char*)pch + 14) = 0;
     
412.                 *((char*)pch + 15) = 0;
     
413.         }
     
414.         
     
415.         pch += (n + 11 + 4);
     
416.         left -= (n + 11 + 4);
     
417.     }
     
418.     assert(left == 0);
     
419. }
     
420. 
     
421. int FlvMediaType(const char* flv_buffer, int len){
     
422.     if(len < 1){
     
423.         goto LABEL;
     
424.     }
     
425. 
     
426.     if(flv_buffer[0] == 0x09){
     
427.         return media_video;
     
428.     }else if(flv_buffer[0] == 0x08){
     
429.         return media_audio;
     
430.     }
     
431. LABEL:
     
432.     assert(false);
     
433.     return media_none;
     
434. }
     
435. 
     
436. int FlvTagBytes(int* head, int* tail){
     
437.     if(head) *head = 11;
     
438.     if(tail) *tail = 4;
     
439.     return 15;
     
440. }
     
441. 
     
442. 
     
443. 
     
444. const static BYTE hdrflvout[] = {
     
445.     0x46,0x4C,0x56,0x01,0x05,0x00,0x00,0x00,0x09,
     
446.     0x00,0x00,0x00,0x00,
     
447. };
     
448. 
     
449. CFlvWrite::CFlvWrite(void){
     
450.         m_bOk = FALSE;
     
451.         m_hFile = NULL;
     
452.     m_need_sps = TRUE;
     
453.     m_need_kfrm = TRUE;
     
454.     m_need_aach = TRUE;
     
455.     m_base_tick_video = 0;
     
456.     m_base_tick_audio = 0;
     
457. }
     
458. 
     
459. CFlvWrite::~CFlvWrite(void){
     
460.         Close();
     
461. }
     
462. 
     
463. HRESULT CFlvWrite::Open(LPCTSTR szOutName, LPCTSTR szExtParam){
     
464.         if(m_bOk)
     
465.                 return S_OK;  //已经打开
     
466.         m_bOk = FALSE;
     
467. 
     
468.         m_hFile = _tfopen(szOutName, _T("wb"));
     
469.         if( m_hFile <= 0)
     
470.                 return E_FAIL;
     
471.     fwrite(hdrflvout, sizeof(hdrflvout), 1, m_hFile);
     
472. 
     
473.         m_bOk = TRUE;
     
474.         return S_OK;
     
475. }
     
476. 
     
477. HRESULT CFlvWrite::Write(BYTE* ppData, int nLen){
     
478.         SingleLock l(m_cs);
     
479.     if(!m_bOk){
     
480.                 return E_FAIL;
     
481.     }
     
482. 
     
483.     if(m_hFile == NULL){
     
484.         ASSERT(FALSE);     
     
485.         return E_FAIL;
     
486.     }
     
487. 
     
488.     int sps_len = 0;
     
489.     char* sps_buf;
     
490.     if(m_need_sps){
     
491.         sps_len = FlvGetSpsFrame(sps_buf);
     
492.     }
     
493. 
     
494.     int keyframe_len = 0;
     
495.     char* kfrm_buf;
     
496.     if(m_need_kfrm){
     
497.         keyframe_len = FlvGetLastKeyFrame(kfrm_buf);
     
498.     }
     
499. 
     
500.     int aac_len = 0;
     
501.     char* aac_buf;
     
502.     if(m_need_aach){
     
503.         aac_len = FlvGetAacFrame(aac_buf);
     
504.     }
     
505. 
     
506.     while(nLen > 0){
     
507.         int len = FlvFrameLength(ppData, nLen);
     
508.         ASSERT(len != -1);
     
509. 
     
510.         int type = FlvMediaType((const char *) ppData, len);
     
511.         ASSERT(type != media_none);
     
512. 
     
513.         if(type == media_audio){
     
514.             if(m_need_aach){
     
515.                 BOOL aach = FlvIsAacHeaderFrame(ppData, len);
     
516.                 if(aach){
     
517.                     m_need_aach = FALSE;
     
518.                     FlvSetDts(0, ppData, len, FALSE);
     
519.                     fwrite(ppData, 1, len, m_hFile);
     
520.                     goto LABEL;
     
521.                 }else if(aac_len){
     
522.                     FlvSetDts(0, aac_buf, aac_len, FALSE);
     
523.                     fwrite(aac_buf, 1, aac_len, m_hFile);
     
524.                     m_need_aach = FALSE;
     
525.                 }else{
     
526.                     goto LABEL;
     
527.                 }
     
528.             }
     
529. 
     
530.             ASSERT(!m_need_aach);
     
531.             DWORD ts = FlvGetDts(ppData, len);
     
532.             if(m_base_tick_audio == 0){
     
533.                 m_base_tick_audio = ts;
     
534.             }
     
535. 
     
536.             FlvSetDts(ts - m_base_tick_audio, ppData, len, FALSE);
     
537.             fwrite(ppData, 1, len, m_hFile);
     
538.         }else{
     
539.             BOOL sps = FlvIsSpsFrame(ppData, len);
     
540.             if(sps){
     
541.                 FlvSetDts(0, ppData, len, TRUE);
     
542.                 fwrite(ppData, 1, len, m_hFile);
     
543.                 m_need_sps = FALSE;
     
544.                 goto LABEL;
     
545.             }
     
546.             
     
547.             if(m_need_sps){
     
548.                 if(sps_len == 0){
     
549.                     goto LABEL;
     
550.                 }
     
551.                 FlvSetDts(0, sps_buf, sps_len, TRUE);
     
552.                 fwrite(sps_buf, 1, sps_len, m_hFile);
     
553.                 m_need_sps = FALSE;
     
554.             }
     
555. 
     
556.             DWORD ts = FlvGetDts(ppData, len);
     
557.             if(m_base_tick_video == 0){
     
558.                 m_base_tick_video = ts;
     
559.             }
     
560. 
     
561.             if(FlvIsKeyFrame(ppData, len)){
     
562.                 m_need_kfrm = FALSE;
     
563.             }else if(m_need_kfrm){
     
564.                 if(keyframe_len == 0){
     
565.                     goto LABEL;
     
566.                 }
     
567. 
     
568.                 FlvSetDts(0, kfrm_buf, keyframe_len, TRUE);
     
569.                 fwrite(kfrm_buf, 1, keyframe_len, m_hFile);
     
570.                 m_need_kfrm = FALSE;
     
571.             }
     
572. 
     
573.             FlvSetDts(ts - m_base_tick_video, ppData, len, FALSE);
     
574.             fwrite(ppData, 1, len, m_hFile);
     
575.         }
     
576. LABEL:
     
577.         ppData += len;
     
578.         nLen -= len;
     
579.     }
     
580. 
     
581.     return S_OK;
     
582. }
     
583. 
     
584. 
     
585. HRESULT CFlvWrite::Close(){
     
586.     if(m_hFile){
     
587.                 fclose(m_hFile);
     
588.     }
     
589. 
     
590.     m_base_tick_video = m_base_tick_audio = 0;
     
591.     m_need_aach = m_need_sps = m_need_kfrm = TRUE;
     
592.         m_hFile = NULL;
     
593.         m_bOk = FALSE;
     
594.         return S_OK;
     
595. }

复制代码

AD8018

貌似能实现无限长度的视频会议！Great！我需要！

wansbest

感谢各位，我们公司就是做网络会议的，不过我正在做的是会后的一个附加功能，提供会议的录制，要求对于会

中当中的视频数据，音频数据等。最后全部整合成一个文件，支持会后回放。我也就是一个新手，今年刚毕业

的，在这边也基本上给前辈打打下手，以后不懂得地方还得请各位多多关照！！！