H264数据avi文件封装和拆解

2024年1月3日发(作者：)

71.

72.

int64_t _off_set;

73.

74.

75.

int _frist_serial;

76.

int _cur_serial;

77.

int64_t _frist_st;

78.

int64_t _cur_st;

79.

80.

private81.

82.

void:

83.

void avi_write_char( avi_write_uint16(uint16_t w);

char c);

84.

void avi_write_uint32(uint32_t dw );

85.

void avi_write_fourcc(char fcc[4] );

86.

int64_t avi_tell();

int avi_write_buff(void* buff,int size);

87.

int64_t avi_seek(int64_t offset);

88.

89.

90.

void

void avi_set_fourcc(

avi_set_dw( voidvoid *_p, char fcc[4]);

91.

92.

void avi_set_dw64( void *_p, uint32_t dw );

*_p, int64_t dw );

93.

94.

void avi_write_header();

95.

void96.

void avi_write_idx();

avi_write_idx_hwx();

97.

98.

99.

public

int#ifdef VIDEO_CLIPint avi_open( :

write_frame(constvoid char *data,

* filename);

int size, int b_key );

#endifint avi_write_clip(VideoClip * clip);

int64_t get_avi_file_size();

int64_t avi_close();

public

:

void

int get_frist_serial();

avi_fflush();

int64_t get_frist_st();

int get_cur_serial();

int64_t get_cur_st();

int get_cur_fream_num();

//获取当前已经存盘数据的索引区

int get_cur_idx_hwx(AVI_IDX_HWX* idx,int fream_num);

};

#endif

100.

101.

102.

103.

104.

105.

106.

107.

108.

109.

110.

111.

112.

113.

114.

115.

116.

117.

118.

119.

120.

121.

122.

123.

[cpp]

01.

02.

#ifndef AVI_UTILS_READER_H_03.

#define AVI_UTILS_READER_H_

04.

05.

typedef06.

typedef long long int64_t;

07.

typedef unsigned char uint8_t;

08.

typedef unsigned short uint16_t;

09.

unsigned uint32_t;

10.

#include "avi_writer.h"11.

12.

13.

typedef14.

{

struct

15.

16.

FILE *f;

17.

18.

char fcc[4];

19.

20.

float f_fps;

21.

22.

int i_width;

23.

int i_height;

24.

int64_t i_movi;

25.

int64_t i_movi_end;

26.

int64_t i_riff;

27.

28.

29.

int i_frame;

30.

uint32_t *idx;

int i_idx_max;

31.

uint32_t *idx_hwx;

32.

} avi_read_t;

33.

34.

35.

36.

typedef37.

struct avi_idx1_hwx{

38.

int39.

int is_key;

40.

int pos;

size;

41.

int64_t st;

int serial;

42.

}IDX_HWX;

43.

44.

45.

//46.

int读取avi标准索引区47.

avi_read_avi_idx1(avi_read_t* a,AVI_IDX**idx);

48.

49.

50.

int51.

int avi_read_idx_hwx(avi_read_t* a,IDX_HWX** idx);

52.

avi_read( avi_read_t *a, void *buf,IDX_HWX* idx);

53.

54.

55.

void56.

avi_rd_init( avi_read_t *a, FILE *f, float *f_fps,int *width,int *height);

57.

int58.

int avi_read( avi_read_t *a,

59.

void avi_read_frame(avi_read_t *a,

void *buf,

voidint *buf,

buf_size,

int buf_size,int64_t pos);

int* b_key );

60.

avi_rd_end( avi_read_t * a);

61.

62.

#endif /* AVI_READER_H_ */

[cpp]

01.

02.

/*03.

* avi_

04.

*

#include  
#include  
05. 
06. 
#include  
07. 
#include "avi_writer.h" 
08. 
#include "avi_reader.h" 
09. 
 
 
10. 
 
11. 
 
12. 
uint16_t avi_read_uint16( avi_read_t *a){ 
 
12. 
13. 
{14. 
    uint16_t dw; 
15. 
 
 
16. 
    dw=fgetc(a->f);17. 
    dw|=fgetc(a->f)<<8; 
18. 
 
 
19. 
    return dw;20. 
}21. 
 
 
 
22. 
uint32_t avi_read_uint32( avi_read_t *a)23. 
{ 
24. 
    uint32_t dw(0); 
25. 
 
 
26. 
    unsigned char c = 0;    c= fgetc(a->f); 
27. 
28. 
    
 
29. 
    dw |=(c&0x000000ff); 
30. 
    c = 0; 
31. 
    c= fgetc(a->f); 
32. 
    dw |= (c&0x000000ff)<<8; 
33. 
 
 
34. 
    c = 0;35. 
    c= fgetc(a->f); 
36. 
    dw |= (c&0x000000ff)<<16; 
37. 
    c = 0; 
38. 
    c= fgetc(a->f); 
39. 
    dw |= (c&0x000000ff)<<24; 
40. 
    c = 0; 
41. 
    /*42. 
    dw = fgetc(a->f); 
 
43. 
    dw |= (fgetc(a->f)&0xff)<<8; 
44. 
    dw |= (fgetc(a->f)&0xff)<<16; 
45. 
    dw |= (fgetc(a->f)&0xff)<<24; 
46. 
    */47. 
    
  
 
48. 
}  
return dw;  
49. 
  
50. 
int64_t avi_read_int64( avi_read_t *a)  
51. 
{  
52. 
    int64_t dw;  
53. 
  
54. 
    dw = (int64_t) fgetc(a->f);  
55. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<8;  
56. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<16;  
57. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<24;  
58. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<32;  
59. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<40;  
60. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<48;  
61. 
    dw |=(int64_t) (fgetc(a->f)&0xff)<<56;  
62. 
  
63. 
    
64. 
}  
return dw;  
65. 
  
66. 
void67. 
{  
 avi_read_fourcc( avi_read_t *a, char fcc[4] )  
68. 
    fcc[0]=fgetc(a->f);    
69. 
    fcc[1]=fgetc(a->f);  
70. 
    fcc[2]=fgetc(a->f);    
71. 
    fcc[3]=fgetc(a->f);  
72. 
}  
73. 
  
74. 
  
75. 
static76. 
{  
 void avi_red_dw( void *_p, uint32_t dw )  
77. 
    uint8_t *p =(uint8_t *)_p;  
78. 
  
79. 
    p[0] = ( dw      )&0xff;  
80. 
    p[1] = ( dw >> 8 )&0xff;  
81. 
    p[2] = ( dw >> 16)&0xff;  
82. 
    p[3] = ( dw >> 24)&0xff;  
83. 
}  
84. 
  
85. 
  
86. 
static87. 
{  
 void avi_read_header( avi_read_t *a )  
88. 
    
89. 
    unsigned 
char buf[8];  
90. 
  
int uint32_data;  
91. 
    avi_read_fourcc( a, buf );  
    a->i_riff = avi_read_uint32( a);  
91. 
92. 
    a->i_riff = avi_read_uint32( a);  
93. 
    avi_read_fourcc( a, buf );  
94. 
  
95. 
    avi_read_fourcc( a, buf );  
96. 
    uint32_data = avi_read_uint32( a );  
97. 
    avi_read_fourcc( a, buf );  
98. 
  
    avi_read_fourcc( a, buf );  
100. 
99.     uint32_data = avi_read_uint32( a );  
101. 
    uint32_data = avi_read_uint32( a );  
102. 
    uint32_data = avi_read_uint32( a );  
103. 
    uint32_data = avi_read_uint32( a );  
104. 
    uint32_data = avi_read_uint32( a);  
105. 
    a->i_frame = avi_read_uint32( a );  
106. 
    uint32_data = avi_read_uint32( a );  
107. 
    uint32_data = avi_read_uint32( a );  
108. 
    uint32_data = avi_read_uint32( a );  
109. 
    a->i_width = avi_read_uint32( a );  
110. 
    a->i_height = avi_read_uint32( a );  
111. 
    uint32_data = avi_read_uint32( a );  
112. 
    uint32_data = avi_read_uint32( a );  
113. 
    uint32_data = avi_read_uint32( a );  
114. 
    uint32_data = avi_read_uint32( a );  
115. 
  
116. 
    avi_read_fourcc( a, buf );  
117. 
    uint32_data = avi_read_uint32( a );  
118. 
    avi_read_fourcc( a, buf );  
119. 
  
120. 
    avi_read_fourcc( a, buf );  
121. 
    uint32_data = avi_read_uint32( a );  
122. 
    avi_read_fourcc( a, buf );  
123. 
    avi_read_fourcc( a, a->fcc );  
124. 
    uint32_data = avi_read_uint32( a );  
125. 
    uint32_data = avi_read_uint32( a );  
126. 
    uint32_data = avi_read_uint32( a );  
127. 
    uint32_data = avi_read_uint32( a );  
128. 
    a->f_fps = (129. 
    uint32_data = avi_read_uint32( a );  
float)(avi_read_uint32( a )/1000);  
130. 
    a->i_frame = avi_read_uint32( a );  
131. 
    uint32_data = avi_read_uint32( a );  
132. 
    uint32_data = avi_read_uint32( a );  
133. 
    uint32_data = avi_read_uint32( a );  
134. 
    uint32_data = avi_read_uint32( a );  
135. 
    a->i_width = avi_read_uint16( a );  
136. 
    a->i_height = avi_read_uint16( a );  
137. 
  
138. 
    avi_read_fourcc( a, buf );  
139. 
    uint32_data = avi_read_uint32( a );  
140. 
    uint32_data = avi_read_uint32( a );  
141. 
    uint32_data = avi_read_uint32( a );  
142. 
    uint32_data = avi_read_uint32( a );  
143. 
    avi_read_uint16( a );  
144. 
    avi_read_uint16( a );  
145. 
    avi_read_fourcc( a,  a->fcc );  
146. 
    uint32_data = avi_read_uint32( a );  
147. 
    uint32_data = avi_read_uint32( a );  
148. 
    uint32_data = avi_read_uint32( a );  
149. 
    uint32_data = avi_read_uint32( a );  
150. 
    uint32_data = avi_read_uint32( a );  
151. 
  
152. 
    avi_read_fourcc( a, buf );  
153. 
    a->i_movi_end = avi_read_uint32( a ) -4;  
154. 
    avi_read_fourcc( a, buf );  
155. 
  
156. 
#if 0157. 
    
  
158. 
    
/* Append idx chunk */  
159. 
    {  
if( a->i_idx_max <= a->i_frame )  
160. 
        a->i_idx_max += 1000;  
161. 
        a->idx =(uint32_t*)realloc(a->idx, a->i_idx_max * 16 );  
162. 
    }  
163. 
  
164. 
    memcpy( &a->idx[4*a->i_frame+0], 
165. 
    avi_set_dw( &a->idx[4*a->i_frame+1], b_key ? AVIIF_KEYFRAME : 0 );  
"00dc", 4 );  
166. 
    avi_set_dw( &a->idx[4*a->i_frame+2], i_pos );  
167. 
    avi_set_dw( &a->idx[4*a->i_frame+3], size );  
168. 
#endif169. 
}  
  
170. 
/*171. 
static void avi_read_idx( avi_read_t *a ) 
{ 
 
171. 
172. 
{173. 
    char buf[8]; 
174. 
 
 
175. 
    avi_read_fourcc( a, buf );176. 
    a->i_frame = avi_read_uint32( a ) / 16; 
177. 
    //fwrite( a->idx, a->i_frame * 16, 1, a->f ); 
178. 
}*/ 
179. 
  
  
180. 
//181. 
int读取avi标准索引区  
182. 
{  
 avi_read_avi_idx1(avi_read_t* a,AVI_IDX**idx)  
183. 
    
184. 
    
char buf[8];  
185. 
  
char* idx_buff = NULL;  
186. 
    
187. 
  
int i_movi_end = a->i_movi_end;  
188. 
    
189. 
    
int idx_pos_start;  
190. 
    
int191. 
    
int idx_pos_end;  
192. 
    int64_t temp;  
//int64_t riff = a->i_riff+(56*4-4); idx_len;  
  
193. 
  
194. 
    
195. 
    
int ret;  
196. 
    
int197. 
  
int frame_num =0;  
 i=0;  
198. 
    temp=fseek(a->f,i_movi_end,SEEK_SET);  
199. 
  
200. 
    memset(buf,0,8);  
201. 
    avi_read_fourcc( a, buf );  
202. 
    
203. 
    {  
if(strcmp(buf,"idx1"))  
204. 
        printf(205. 
        
"<<<<<<>>>>read buf is %sn"206. 
    }  
return -1;  
,buf);  
207. 
  
208. 
    frame_num = avi_read_uint32(a)/16;  
209. 
  
210. 
  
211. 
    
212. 
    {  
if(frame_num <=0 )  
213. 
        *idx = NULL;  
214. 
        printf(215. 
        
"<<<<<<>>>>n");  
216. 
    }  
return frame_num;  
217. 
  
218. 
    AVI_IDX* idx_tmp = (AVI_IDX*)calloc(frame_num,219. 
  
sizeof(AVI_IDX));  
220. 
  
221. 
    
222. 
    {  
for(i=0;i
223. 
        memset(buf,0,8);  
224. 
        avi_read_fourcc( a, buf );  
225. 
        
226. 
        {  
if(strcasecmp(buf,"00dc"))  
227. 
            printf(228. 
            
"<<<<<<>>>>n");  
229. 
        }  
break;  
230. 
        idx_tmp[i].is_key=avi_read_uint32(a);  
231. 
        idx_tmp[i].pos = avi_read_uint32(a);  
232. 
        idx_tmp[i].size = avi_read_uint32(a);  
233. 
    }  
234. 
  
235. 
    
236. 
    {  
if(i!=frame_num)  
237. 
        free(idx_tmp);  
238. 
        idx_tmp = NULL;  
239. 
        
240. 
    }  
return 0;  
241. 
  
242. 
    *idx = idx_tmp;  
243. 
    
244. 
}  
return frame_num;  
245. 
  
246. 
  
247. 
  
248. 
int249. 
{  
 avi_read_idx_hwx(avi_read_t* a,IDX_HWX** idx)  
250. 
    
    
charchar buf[8];  
* idx_buff = NULL;  
250. 
251. 
    
252. 
  
char* idx_buff = NULL;  
253. 
    
254. 
    
int riff = a->i_riff+8;  
255. 
    
int riff2 = a->i_riff;  
256. 
    
int idx_pos_start;  
257. 
    
int258. 
    
int idx_pos_end;  
259. 
    int64_t temp;  
//int64_t riff = a->i_riff+(56*4-4); idx_len;  
  
260. 
  
261. 
    
262. 
    
int ret;  
263. 
    
int  
int frame_num =0;  
 i=0;  
264. 
265. 
    temp=fseek(a->f,riff,SEEK_SET);  
266. 
  
267. 
    memset(buf,0,8);  
268. 
    avi_read_fourcc( a, buf );  
269. 
    
270. 
    {  
if(strcmp(buf,"ihwx"))  
        
271. 
<<<<<<>>>>read buf is %sn",buf);// Ipnc_DbgPrintf2(_TraceError,"272. 
        
  
273. 
    }  
return -1;  
274. 
  
275. 
  
276. 
    idx_pos_start = ftell( a->f );  
277. 
    fseek(a->f,0,SEEK_END);  
278. 
    idx_pos_end  = ftell( a->f );  
279. 
  
280. 
    idx_len  = idx_pos_end - idx_pos_start;  
281. 
    fseek(a->f,0-idx_len,SEEK_END);  
282. 
  
283. 
  
284. 
    frame_num = avi_read_uint32(a)/28;  
285. 
  
286. 
    
287. 
    {  
if(frame_num <=0 )  
288. 
        *idx = NULL;  
289. 
        
290. 
    }  
return frame_num;  
291. 
  
292. 
    IDX_HWX* idx_hwx = (IDX_HWX*)calloc(frame_num,293. 
  
sizeof(IDX_HWX));  
294. 
  
295. 
    
296. 
    {  
for(i=0;i
297. 
        memset(buf,0,8);  
298. 
        avi_read_fourcc( a, buf );  
299. 
        
300. 
        {  
if(strcasecmp(buf,"hwx0"))  
301. 
            
302. 
        }  
break;  
303. 
        idx_hwx[i].is_key=avi_read_uint32(a);  
304. 
        idx_hwx[i].pos = avi_read_uint32(a);  
305. 
        idx_hwx[i].size = avi_read_uint32(a);  
306. 
        idx_hwx[i].serial = avi_read_uint32(a);  
307. 
        idx_hwx[i].st =(308. 
    }  
long long)avi_read_int64(a);  
309. 
  
310. 
    
311. 
    {  
if(i!=frame_num)  
312. 
        free(idx_hwx);  
313. 
        idx_hwx = NULL;  
314. 
        *idx = NULL;  
315. 
        
316. 
    }  
return 0;  
317. 
  
318. 
    *idx = idx_hwx;  
319. 
    
320. 
}  
return frame_num;  
321. 
  
322. 
  
323. 
void324. 
{  
 avi_rd_init( avi_read_t *a, FILE *f, float *f_fps,int *width,int *height)  
325. 
    
326. 
    a->f = f;  
char hwx_fcc[8];  
327. 
    a->f_fps = 0;  
328. 
    a->i_width = 0;  
329. 
    a->i_height = 0;  
    a->i_frame = 0;  
329. 
330. 
    a->i_frame = 0;  
331. 
    a->i_movi = 0;  
332. 
    a->i_riff = 0;  
333. 
    a->i_movi_end = 0;  
334. 
    a->i_idx_max = 0;  
335. 
    a->idx = NULL;  
336. 
    a->idx_hwx = NULL;  
337. 
    avi_read_header( a );  
338. 
    *f_fps=a->f_fps;  
339. 
    *width=a->i_width;  
340. 
    *height=a->i_height;  
341. 
  
342. 
  
343. 
}  
344. 
  
345. 
int346. 
{  
 avi_read( avi_read_t *a, void *buf, int buf_size, int* b_key )  
347. 
    
348. 
    
int349. 
    int64_t i_pos = ftell( a->f );  
int frame_size = 0;  
 read_size = 0;  
350. 
    
351. 
    
char fcc[8];  
352. 
  
char c;  
353. 
    
354. 
        
if (!a || !buf || (buf_size<16))  
355. 
      
return 0;  
356. 
    
357. 
  
//avi_read_idx_hwx("ihwx",hwx_fcc);  
358. 
    
359. 
    
if (b_key) *b_key = 0;  
360. 
    {  
while ((frame_size<=0) && (!feof(a->f)))  
361. 
        avi_read_fourcc( a,  fcc);362. 
        fcc[4] = 
//  
363. 
        
364. 
        {  
if (!strcmp(fcc, 
'0';  
"00dc"))  
365. 
            frame_size = avi_read_uint32( a );  
366. 
            
367. 
            {  
if ((frame_size>16) && (frame_size
368. 
                read_size = fread( buf, 1, frame_size, a->f );  
369. 
                
370. 
                {  
if (read_size == frame_size)  
371. 
                    
372. 
                        c = fgetc( a->f );if (frame_size&0x01 )  
373. 
  
/* pad */  
374. 
                    a->i_frame++;  
375. 
                }  
376. 
            }  
377. 
        }  
378. 
    }  
379. 
  
380. 
    
381. 
}  
return frame_size;  
382. 
  
383. 
/*384. 
 * sucess return frame_size 
385. 
 * faild  return -1 
386. 
 */387. 
int  
 
388. 
{  
 avi_read_frame(avi_read_t *a, void *buf, int buf_size,int64_t pos)  
389. 
    
390. 
    
int frame_size = 0;  
391. 
    
int read_size = 0;  
392. 
    
char393. 
    int64_t i_pos = ftell( a->f );  
char fcc[8];  
 c;  
394. 
  
395. 
    
396. 
        
if (!a || !buf || (buf_size<16))  
397. 
  
return -1;  
398. 
  
399. 
    
400. 
        fseek(a->f,pos,SEEK_SET);  
if(i_pos!=pos)  
401. 
  
402. 
    avi_read_fourcc( a,  fcc);403. 
    fcc[4] = 
//  
404. 
    
405. 
    {  
if (!strcmp(fcc, 
'0';  
"00dc"))  
406. 
        frame_size = avi_read_uint32( a );  
407. 
        
408. 
        {  
if ((frame_size>16) && (frame_size
            read_size = fread( buf, 1, frame_size, a->f );  
408. 
409. 
            read_size = fread( buf, 1, frame_size, a->f );  
410. 
            
411. 
            {  
if (read_size == frame_size)  
412. 
                
413. 
                    c = fgetc( a->f );if (frame_size&0x01 )  
414. 
            }  
/* pad */  
415. 
            
416. 
            {  
else  
417. 
                
418. 
            }  
return -1;  
419. 
        }  
420. 
    }  
421. 
    
422. 
    {  
else  
423. 
        
424. 
    }  
return -1;  
425. 
  
426. 
    
427. 
}  
return frame_size;  
428. 
  
429. 
void430. 
{  
 avi_rd_end( avi_read_t * a)  
431. 
  
}  
[cpp] 
01. 
02. 
/*03. 
 * avi_ 
04. 
 * 
05. 
 */ 
06. 
  
  
07. 
#include 08. 
#include   
09. 
#include   
10. 
#include "avi_writer.h"  
11. 
  
  
12. 
#ifdef WIN3213. 
#include "......media_basemedia_dbg.h"  
14. 
#include "......media_basesync.h"15. 
#else  
  
16. 
#include "sync.h"  
17. 
  
  
18. 
#include19. 
#include  
20. 
#include  
21. 
#include  
22. 
#endif  
23. 
  
  
24. 
/* Flags in avih */25. 
#define AVIF_HASINDEX       0x00000010  // Index at end of file?  
26. 
#define AVIF_ISINTERLEAVED  0x00000100  
27. 
#define AVIF_TRUSTCKTYPE    0x00000800  // Use CKType to find key frames?  
28. 
  
29. 
#define AVIIF_KEYFRAME      0x00000010L /* this frame is a key frame.*/30. 
  
  
31. 
  
32. 
  
33. 
avi_writer::avi_writer(int64_t offset,34. 
{  
float fps,int width,int height)  
35. 
    _i_width = width;  
36. 
    _i_height = height;  
37. 
    _f_fps = fps;  
38. 
  
39. 
    memcpy( _fcc,40. 
    _i_width = width;  
"h264",4);  
41. 
    _i_height = height;  
42. 
    _i_frame = 0;  
43. 
    _i_movi = 0;  
44. 
    _i_riff = 0;  
45. 
    _i_movi_end = 0;  
46. 
    _i_idx_max = 0;  
47. 
    _idx = NULL;  
48. 
    _idx_hwx = NULL;  
49. 
  
50. 
    _io_mode = 0; 
51. 
    _start_offset = offset;  
// open write  
52. 
    _off_set = 0;  
53. 
  
54. 
    _frist_serial=0;  
    _cur_serial=0;  
  
54. 
55. 
    _cur_serial=0;  
56. 
  
57. 
    _frist_st=0;  
58. 
    _cur_st=0;  
59. 
}  
60. 
  
61. 
avi_writer::avi_writer(62. 
{  
float fps,int width,int height)  
63. 
    _i_width = width;  
64. 
    _i_height = height;  
65. 
    _f_fps = fps;  
66. 
  
67. 
    memcpy( _fcc,68. 
    _i_width = width;  
"h264",4);  
69. 
    _i_height = height;  
70. 
    _i_frame = 0;  
71. 
    _i_movi = 0;  
72. 
    _i_riff = 0;  
73. 
    _i_movi_end = 0;  
74. 
    _i_idx_max = 0;  
75. 
    _idx = NULL;  
76. 
    _idx_hwx = NULL;  
77. 
  
78. 
    _io_mode = 1;  
    _start_offset = 0;  
// fopen fwrite  
79. 
80. 
    _off_set = 0;  
81. 
  
82. 
    _frist_serial=0;  
83. 
    _cur_serial=0;  
84. 
  
85. 
    _frist_st=0;  
86. 
    _cur_st=0;  
87. 
}  
88. 
  
89. 
avi_writer::~avi_writer()  
90. 
{  
91. 
    
92. 
        free(_idx);  
if(_idx)  
93. 
    _idx = NULL;  
94. 
    
95. 
         free(_idx_hwx);  
if(_idx_hwx)  
96. 
    _idx_hwx = NULL;  
97. 
}  
98. 
  
99. 
void{  
 avi_writer::avi_write_char(char c)  
    
    {  
if(_io_mode)  
        fputc( c, _f_);  
    }  
    
    {  
else  
        write(_f_,&c,1);  
    }  
    _off_set += 1l;  
  
}  
  
void{  
 avi_writer::avi_write_uint16(uint16_t w)  
    
    {  
if(_io_mode)  
        fputc( ( w      ) & 0xff, _f_);  
        fputc( ( w >> 8 ) & 0xff, _f_ );  
    }  
    
    {  
else  
        _buff[0] = ( w      ) & 0xff;  
        _buff[1] = ( w >> 8 ) & 0xff;  
        _buff[2] = 
        write(_f_,_buff,2);  
'0';  
    }  
  
    _off_set += 2l;  
}  
void{  
 avi_writer::avi_write_uint32(uint32_t dw )  
    
    {  
if(_io_mode)  
        fputc( ( dw      ) & 0xff,_f_ );  
        fputc( ( dw >> 8 ) & 0xff,_f_);  
100. 
101. 
102. 
103. 
104. 
105. 
106. 
107. 
108. 
109. 
110. 
111. 
112. 
113. 
114. 
115. 
116. 
117. 
118. 
119. 
120. 
121. 
122. 
123. 
124. 
125. 
126. 
127. 
128. 
129. 
130. 
131. 
132. 
133. 
134. 
134. 
135. 
136. 
137. 
138. 
139. 
140. 
141. 
142. 
143. 
144. 
145. 
146. 
147. 
148. 
149. 
150. 
151. 
152. 
153. 
154. 
155. 
156. 
157. 
158. 
159. 
160. 
161. 
162. 
163. 
164. 
165. 
166. 
167. 
168. 
169. 
170. 
171. 
172. 
173. 
174. 
175. 
176. 
177. 
178. 
179. 
180. 
181. 
182. 
183. 
184. 
185. 
186. 
187. 
188. 
189. 
190. 
191. 
192. 
193. 
194. 
195. 
196. 
197. 
198. 
199. 
200. 
201. 
202. 
203. 
204. 
205. 
206. 
207. 
208. 
209. 
210. 
211. 
212. 
213. 
        fputc( ( dw >> 8 ) & 0xff,_f_);  
        fputc( ( dw >> 16) & 0xff,_f_ );  
        fputc( ( dw >> 24) & 0xff,_f_);  
    }  
    else  
    {  
        _buff[0] = ( dw       ) & 0xff;  
        _buff[1] = ( dw >> 8  ) & 0xff;  
        _buff[2] = ( dw >> 16 ) & 0xff;  
        _buff[3] = ( dw >> 24 ) & 0xff;  
        _buff[4] = '0';  
  
        write(_f_,_buff,4);  
    }  
    _off_set += 4l;  
}  
void avi_writer::avi_write_fourcc(char fcc[4] )  
{  
    if(_io_mode)  
    {  
        fputc( fcc[0],_f_);  
        fputc( fcc[1],_f_);  
        fputc( fcc[2],_f_);  
        fputc( fcc[3],_f_);  
    }  
    else  
    {  
        write(_f_,fcc,4);  
    }  
    _off_set += 4l;  
}  
  
  
int avi_writer::avi_write_buff(void* buff,int size)  
{  
    int ret=0;  
  
    if(_io_mode)  
    {  
        ret = fwrite(buff,1,size,_f_);  
    }  
    else  
    {  
        ret = write(_f_,buff,size);  
    }  
  
    if(ret!=size)  
    {  
        Ipnc_DbgPrintf2(_TraceInfo, "write errorn");  
    }  
  
    _off_set +=(int64_t)ret;  
  
    return ret;  
}  
  
void avi_writer::avi_write_header()  
{  
     avi_write_fourcc("RIFF" );  
    avi_write_uint32(_i_riff > 0 ? _i_riff - 8 : 0xFFFFFFFF );  
    avi_write_fourcc("AVI " );  
  
    avi_write_fourcc("LIST" );  
    avi_write_uint32( 4 + 4*16 + 12 + 4*16 + 4*12 );  
    avi_write_fourcc("hdrl" );  
  
    avi_write_fourcc("avih" );  
    avi_write_uint32(4*16 - 8 );  
    avi_write_uint32(1000000 / _f_fps );  
    avi_write_uint32(0xffffffff );  
    avi_write_uint32(0 );  
    avi_write_uint32(AVIF_HASINDEX|AVIF_ISINTERLEAVED|AVIF_TRUSTCKTYPE);  
    avi_write_uint32(_i_frame );  
    avi_write_uint32(0 );  
    avi_write_uint32(1 );  
    avi_write_uint32(1000000 );  
    avi_write_uint32(_i_width );  
    avi_write_uint32(_i_height );  
    avi_write_uint32(0 );  
    avi_write_uint32(0 );  
213. 
214. 
    avi_write_uint32(0 );  
215. 
    avi_write_uint32(0 );  
216. 
    avi_write_uint32(0 );  
217. 
  
218. 
    avi_write_fourcc(219. 
    avi_write_uint32( 4 + 4*16 + 4*12 );  
"LIST" );  
220. 
    avi_write_fourcc(221. 
  
"strl" );  
222. 
    avi_write_fourcc(223. 
    avi_write_uint32( 4*16 - 8 );  
"strh" );  
224. 
    avi_write_fourcc(225. 
    avi_write_fourcc(_fcc );  
"vids" );  
226. 
    avi_write_uint32(0 );  
227. 
    avi_write_uint32(0 );  
228. 
    avi_write_uint32(0 );  
229. 
    avi_write_uint32(1000 );  
230. 
    avi_write_uint32(_f_fps * 1000 );  
231. 
    avi_write_uint32(0 );  
232. 
    avi_write_uint32(_i_frame );  
233. 
    avi_write_uint32(1024*1024 );  
234. 
    avi_write_uint32(-1 );  
235. 
    avi_write_uint32(_i_width * _i_height );  
236. 
    avi_write_uint32(0 );  
237. 
    avi_write_uint16(_i_width );  
238. 
    avi_write_uint16(_i_height );  
239. 
  
240. 
    avi_write_fourcc(241. 
    avi_write_uint32( 4*12 - 8 );  
"strf" );  
242. 
    avi_write_uint32( 4*12 - 8 );  
243. 
    avi_write_uint32( _i_width );  
244. 
    avi_write_uint32( _i_height );  
245. 
    avi_write_uint16( 1 );  
246. 
    avi_write_uint16( 24 );  
247. 
    avi_write_fourcc( _fcc );  
248. 
    avi_write_uint32(_i_width * _i_height );  
249. 
    avi_write_uint32( 0 );  
250. 
    avi_write_uint32( 0 );  
251. 
    avi_write_uint32( 0 );  
252. 
    avi_write_uint32( 0 );  
253. 
  
254. 
    avi_write_fourcc(255. 
    avi_write_uint32( _i_movi_end > 0 ? _i_movi_end - _i_movi + 4: 0xFFFFFFFF );  
"LIST" );  
256. 
    avi_write_fourcc(257. 
}  
"movi" );  
258. 
  
259. 
void260. 
{  
 avi_writer::avi_set_fourcc( void *_p, char fcc[4] )  
261. 
    uint8_t *p =(uint8_t *)_p;  
262. 
    p[0] = fcc[0];  
263. 
    p[1] = fcc[1];  
264. 
    p[2] = fcc[2];  
265. 
    p[3] = fcc[3];  
266. 
}  
267. 
void268. 
{  
 avi_writer::avi_set_dw( void *_p, uint32_t dw )  
269. 
    uint8_t *p =(uint8_t *)_p;  
270. 
  
271. 
    p[0] = ( dw      )&0xff;  
272. 
    p[1] = ( dw >> 8 )&0xff;  
273. 
    p[2] = ( dw >> 16)&0xff;  
274. 
    p[3] = ( dw >> 24)&0xff;  
275. 
}  
276. 
void277. 
{  
 avi_writer::avi_set_dw64( void *_p, int64_t dw )  
278. 
    uint8_t *p =(uint8_t *)_p;  
279. 
  
280. 
    p[0] = ( dw      )&0xff;  
281. 
    p[1] = ( dw >> 8 )&0xff;  
282. 
    p[2] = ( dw >> 16)&0xff;  
283. 
    p[3] = ( dw >> 24)&0xff;  
284. 
    p[4] = ( dw >> 32)&0xff;  
285. 
    p[5] = ( dw >> 40)&0xff;  
286. 
    p[6] = ( dw >> 48)&0xff;  
287. 
    p[7] = ( dw >> 56)&0xff;  
288. 
}  
289. 
  
290. 
int64_t avi_writer::avi_tell()  
291. 
{  
292. 
    int64_t pos = 0;  
293. 
  
  
293. 
294. 
  
295. 
    
296. 
    {  
if(_io_mode)  
297. 
        pos =(int64_t)ftell(_f_);  
298. 
    }  
299. 
    
300. 
    {  
else  
301. 
        pos = _off_set;  
302. 
    }  
303. 
  
304. 
    
305. 
}  
return pos;  
306. 
  
307. 
  
308. 
int64_t avi_writer::avi_seek(int64_t offset )  
309. 
{  
310. 
    
311. 
        fseek(_f_, offset, SEEK_SET);  
if(_io_mode)  
312. 
    
313. 
        lseek64(_f_,_start_offset+offset,SEEK_SET);  
else  
314. 
}  
315. 
  
316. 
void317. 
{  
 avi_writer::avi_write_idx()  
318. 
    
319. 
    uint32_t* buff = NULL;  
int i=0;  
320. 
  
321. 
  
322. 
    avi_write_fourcc(323. 
    avi_write_uint32(_i_frame * 16 );  
"idx1" );  
324. 
  
325. 
    buff = (uint32_t*)calloc(326. 
    
327. 
    {  
if(!buff)  
sizeof(uint32_t),_i_frame*16);  
328. 
        Ipnc_DbgPrintf2(_TraceInfo, 
329. 
        
330. 
    }  
return ;  
"");  
331. 
  
332. 
    
333. 
    {  
for(i=0;i<_i_frame;i++)  
334. 
        avi_set_fourcc(&buff[4*i+0],335. 
        avi_set_dw(&buff[4*i+1], _idx[i].is_key);  
"00dc");  
336. 
        avi_set_dw(&buff[4*i+2], _idx[i].pos );  
337. 
        avi_set_dw(&buff[4*i+3], _idx[i].size );  
338. 
    }  
339. 
    avi_write_buff(buff,340. 
    free(buff);  
sizeof(uint32_t)*_i_frame * 16);  
341. 
    free(_idx);  
342. 
    _idx  = NULL;  
343. 
}  
344. 
void345. 
{  
 avi_writer::avi_write_idx_hwx()  
346. 
    
347. 
    uint32_t* buff = NULL;  
int i=0;  
348. 
  
349. 
    
350. 
        
if(!_idx_hwx)  
351. 
  
return;  
352. 
    avi_write_fourcc(353. 
    avi_write_uint32(_i_frame);  
"ihwx");  
354. 
  
355. 
    buff = (uint32_t*)calloc(356. 
    
357. 
    {  
if(!buff)  
sizeof(uint32_t),_i_frame*28);  
358. 
        Ipnc_DbgPrintf2(_TraceInfo, 
359. 
        
360. 
    }  
return ;  
"");  
361. 
  
362. 
    Ipnc_DbgPrintf2(_TraceInfo, 
363. 
        _frist_serial,_cur_serial,_frist_st,_cur_st);  
"frist serial:%d end serial:%d frist st:%lld cur st:%lldn",  
364. 
  
365. 
    
366. 
    {  
for(i=0;i<_i_frame;i++)  
367. 
        avi_set_fourcc(&buff[7*i+0],368. 
        avi_set_dw(&buff[7*i+1], _idx_hwx[i]._key);  
"hwx0");  
369. 
        avi_set_dw(&buff[7*i+2], _idx_hwx[i]. );  
370. 
        avi_set_dw(&buff[7*i+3], _idx_hwx[i]. );  
371. 
        avi_set_dw(&buff[7*i+4], _idx_hwx[i].serial);  
372. 
        avi_set_dw64(&buff[7*i+5], _idx_hwx[i].st);  
    }  
372. 
373. 
    }  
374. 
    avi_write_buff(buff,375. 
  
sizeof(uint32_t)*_i_frame*28);  
376. 
    free(buff);  
377. 
    free(_idx_hwx);  
378. 
    _idx_hwx = NULL;  
379. 
}  
380. 
  
381. 
int382. 
{  
 avi_writer::avi_open(const char* filename)  
383. 
    
384. 
    {  
if(!filename)  
385. 
        Ipnc_DbgPrintf2(_TraceError, 
386. 
        
"invalid filenamen");  
387. 
    }  
return -1;  
388. 
  
389. 
    
    {  
if(_io_mode)  
390. 
391. 
        _f_ = fopen(filename,392. 
        
393. 
        {  
if(!_f_)  
"wb+");  
394. 
            Ipnc_DbgPrintf2(_TraceError,  
395. 
                    
396. 
                    errno, filename);  
"create avi file failed 1: error=%d, file=%sn",  
397. 
            
398. 
        }  
return -1;  
399. 
    }  
400. 
    
401. 
    {  
else  
402. 
        _f_ = open(filename,O_CREAT|O_RDWR);  
403. 
        
404. 
        {  
if(_f_ < 0 )  
405. 
            Ipnc_DbgPrintf2(_TraceError,  
406. 
                        
407. 
                        errno, filename);  
"create avi file failed 2: error=%d, file=%sn",  
408. 
            
409. 
        }  
return -1;  
410. 
    }  
411. 
  
412. 
    Ipnc_DbgPrintf2(_TraceError,  
413. 
            
414. 
            filename);  
"create avi file success: %sn",  
415. 
    avi_seek(0);  
416. 
    avi_write_header();  
417. 
    
418. 
}  
return 0;  
419. 
int420. 
{  
 avi_writer::write_frame(void *data, int size, int b_key )  
421. 
    
422. 
    int64_t i_pos = avi_tell();  
int ret=0;  
423. 
  
424. 
    
425. 
    avi_write_fourcc(/* chunk header */  
426. 
    avi_write_uint32(size);  
"00dc" );  
427. 
  
428. 
    ret = avi_write_buff(data,size);  
429. 
  
430. 
    
431. 
    {  
if(size&0x01 )  
432. 
        
433. 
        avi_write_char(0);  
/* pad */  
434. 
    }  
435. 
  
436. 
    
437. 
    
/* Append idx chunk */  
438. 
    {  
if( _i_idx_max <= _i_frame )  
439. 
        _i_idx_max += 1000;  
440. 
        _idx =(AVI_IDX*)realloc(_idx,_i_idx_max*441. 
    }  
sizeof(AVI_IDX));  
442. 
    _idx[_i_frame].is_key = b_key ? AVIIF_KEYFRAME : 0 ;  
443. 
    _idx[_i_frame].pos = i_pos;  
444. 
    _idx[_i_frame].size = size;  
445. 
  
446. 
    _i_frame++;  
447. 
  
448. 
    
449. 
}  
return ret;  
450. 
#ifdef VIDEO_CLIP451. 
int452. 
{  
 avi_writer::avi_write_clip(VideoClip * clip)  
  
    int ret=0;  
452. 
453. 
454. 
455. 
456. 
457. 
458. 
459. 
460. 
461. 
462. 
463. 
464. 
    int ret=0;  
    int j=0,size=0,serial=0;  
    int64_t timest=0;  
    int is_key=0;  
  
    int64_t i_pos = avi_tell();  
  
    //Ipnc_DbgPrintf2(_TraceInfo, "write clip pos:%lld offset:%lldn",i_pos,_off_set);  
  
    /* chunk header */  
    ret = avi_write_buff( clip->get_buff_head(),clip->size());  
/* 
    Ipnc_DbgPrintf2(_TraceInfo, "clip frame num:%d start: serial:%d st:%lld end serial:%d st:%lldn",465. 
466. 
            clip->frame_count(),467. 
            clip->get_frame_serial(0), 
468. 
            clip->get_frame_timest(0), 
469. 
            clip->get_frame_serial(clip->frame_count()-1), 
470. 
            clip->get_frame_timest(clip->frame_count()-1)); 
471. 
    Ipnc_DbgPrintf2(_TraceInfo, "avi file frame num :%dn",_i_frame); 
472. 
*/ 
473. 
    
  
474. 
    {  
for (j=0; jframe_count(); j++)  
475. 
        
476. 
        
/* Append idx chunk */477. 
        {  
if( _i_idx_max <= _i_frame )  
  
478. 
            _i_idx_max += 1000;  
479. 
            _idx =(AVI_IDX*)realloc(_idx,_i_idx_max*            _idx_hwx =sizeof(AVI_IDX));  
480. 
(AVI_IDX_HWX*)realloc(_idx_hwx, _i_idx_max * 
481. 
        }  
sizeof(AVI_IDX_HWX));  
482. 
  
483. 
        is_key = clip->get_frame_key(j);  
484. 
        size = clip->get_frame_size(j);  
485. 
        serial = clip->get_frame_serial(j);  
486. 
        timest = clip->get_frame_timest(j);  
487. 
  
488. 
  
489. 
        
490. 
            _frist_serial=serial;  
if(!_frist_serial)  
491. 
        _cur_serial=serial;  
492. 
        
493. 
            _frist_st=timest;  
if(!_frist_st)  
494. 
        _cur_st=timest;  
495. 
  
496. 
        _idx[_i_frame].is_key = is_key ? AVIIF_KEYFRAME : 0 ;  
497. 
        _idx[_i_frame].pos = i_pos;  
498. 
        _idx[_i_frame].size = size;  
499. 
  
500. 
        _idx_hwx[_i_frame]._key = is_key ? AVIIF_KEYFRAME : 0 ;  
501. 
        _idx_hwx[_i_frame]. = i_pos;  
502. 
        _idx_hwx[_i_frame]. = size;  
503. 
        _idx_hwx[_i_frame].serial = serial;  
504. 
        _idx_hwx[_i_frame].st = timest;  
505. 
  
506. 
        i_pos += (size+8+(size&0x01));  
507. 
  
508. 
        _i_frame++;  
509. 
    }  
510. 
  
511. 
    
512. 
}  
return ret;  
513. 
#endif514. 
int64_t avi_writer::avi_close()  
  
515. 
{  
516. 
    int64_t file_size = 0;  
517. 
    _i_movi_end = avi_tell();  
518. 
  
519. 
    
520. 
    avi_write_idx();  
/* write index */  
521. 
  
522. 
    _i_riff = avi_tell();  
523. 
    
524. 
    
//Ipnc_DbgPrintf2(_TraceInfo, "avi end:%lld offset:%lldn",_i_riff,_off_set);525. 
    
//idx hwx  
526. 
  
//avi_write_idx_hwx();  
  
527. 
    file_size = avi_tell();  
528. 
    
529. 
    
//Ipnc_DbgPrintf2(_TraceInfo, "avi file len :%lld offset:%lldn",file_size,_off_set);530. 
    avi_seek(0);  
/* Fix header */  
  
    avi_write_header();  
530. 
531. 
532. 
533. 
534. 
535. 
536. 
537. 
538. 
539. 
540. 
541. 
542. 
543. 
544. 
545. 
546. 
547. 
548. 
549. 
550. 
551. 
552. 
553. 
554. 
555. 
556. 
557. 
558. 
559. 
560. 
561. 
562. 
563. 
564. 
565. 
566. 
567. 
568. 
569. 
570. 
571. 
572. 
573. 
574. 
575. 
576. 
577. 
578. 
579. 
580. 
581. 
582. 
583. 
584. 
585. 
586. 
587. 
588. 
589. 
590. 
591. 
592. 
593. 
    avi_write_header();  
  
    if(_io_mode)  
    {  
        fclose(_f_);  
        _f_ = NULL;  
    }  
    else  
    {  
        close(_f_);  
        _f_ = 0;  
    }  
  
    return file_size;  
}  
  
int64_t avi_writer::get_avi_file_size()  
{  
    return _off_set;  
}  
  
void avi_writer::avi_fflush()  
{  
    if(_io_mode)  
    {  
        fflush(_f_);  
    }  
}  
  
int avi_writer::get_frist_serial()  
{  
    return _frist_serial;  
}  
int avi_writer::get_cur_serial()  
{  
    return _cur_serial;  
}  
int64_t avi_writer::get_frist_st()  
{  
    return _frist_st;  
}  
int64_t avi_writer::get_cur_st()  
{  
    return _cur_st;  
}  
int avi_writer::get_cur_fream_num()  
{  
    return _i_frame;  
}  
int avi_writer::get_cur_idx_hwx(AVI_IDX_HWX* idx,int fream_num)  
{  
    if(fream_num <=0 || !idx)  
    {  
        Ipnc_DbgPrintf2(_TraceInfo,"invalid idx or ");  
        return -1;  
    }  
    if(!_idx_hwx)  
    {  
        Ipnc_DbgPrintf2(_TraceInfo,"invalid _");  
        return -1;  
    }  
    memcpy(idx,_idx_hwx,fream_num* sizeof(AVI_IDX_HWX));  
    return 0;  
}