flv文件的onMetaData部分解析

参考flv的spec文档，写了个解析onMetaData，代码没有整理

点击(此处)折叠或打开

1. /*
   
2.  * Copyright (c) 2013 Steven Liu
   
3.  *
   
4.  *
   
5.  * FFmpeg is free software; you can redistribute it and/or
   
6.  * modify it under the terms of the GNU Lesser General Public
   
7.  * License as published by the Free Software Foundation; either
   
8.  * version 2.1 of the License, or (at your option) any later version.
   
9.  *
   
10.  * FFmpeg is distributed in the hope that it will be useful,
    
11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    
13.  * Lesser General Public License for more details.
    
14.  *
    
15.  * You should have received a copy of the GNU Lesser General Public
    
16.  * License along with FFmpeg; if not, write to the Free Software
    
17.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
18.  */
    
19. 
    
20. #include <stdio.h>
    
21. #include <stdlib.h>
    
22. #include <string.h>
    
23. #include <unistd.h>
    
24. #include <fcntl.h>
    
25. #include <sys/types.h>
    
26. #include <sys/stat.h>
    
27. #include <errno.h>
    
28. 
    
29. #define TAG_FLV_F 'F'
    
30. #define TAG_FLV_L 'L'
    
31. #define TAG_FLV_V 'V'
    
32. #define TAG_TYPE_SCRIPTDATA 0x12
    
33. int script_type_parse(unsigned char *data);
    
34. 
    
35. union av_intfloat64 {
    
36.     uint64_t i;
    
37.     double f;
    
38. };
    
39. 
    
40. enum script_data_type {
    
41.     Number = 0,
    
42.     Boolean,
    
43.     String,
    
44.     Object,
    
45.     MovieClip,
    
46.     Null,
    
47.     Undefined,
    
48.     Reference,
    
49.     EcmaArray,
    
50.     ObjectEndMarker,
    
51.     StringArray,
    
52.     Date,
    
53.     LongString,
    
54. };
    
55. typedef enum script_data_type script_type_t;
    
56. 
    
57. struct script_string {
    
58.     char len[2];
    
59. };
    
60. typedef struct script_string String_t;
    
61. 
    
62. struct flv_header {
    
63.     unsigned char tag_f;
    
64.     unsigned char tag_l;
    
65.     unsigned char tag_v;
    
66.     unsigned char version;
    
67.     unsigned char audio_and_video;
    
68.     unsigned char DataOffset[4];
    
69. };
    
70. typedef struct flv_header header_t;
    
71. 
    
72. struct flv_tag {
    
73.     unsigned char tagtype;
    
74.     unsigned char size[3];
    
75.     unsigned char timestamp[3];
    
76.     unsigned char extent_timestamp;
    
77.     unsigned char stream_id[3];
    
78. };
    
79. typedef struct flv_tag tag_t;
    
80. 
    
81. struct flv_body {
    
82.     tag_t tag;
    
83.     // unsigned char PreviousTagSize[2];
    
84. };
    
85. typedef struct flv_body body_t;
    
86. 
    
87. struct object_name {
    
88.     unsigned short length;
    
89.     unsigned char name;
    
90. };
    
91. typedef struct object_name object_name_t;
    
92. 
    
93. struct script_object {
    
94.     object_name_t name;
    
95. };
    
96. typedef struct script_object_name script_object_t;
    
97. 
    
98. 
    
99. /**
    
100.  * Reinterpret a 64-bit integer as a double.
     
101.  */
     
102. static double int2double(uint64_t i)
     
103. {
     
104.     union av_intfloat64 v;
     
105.     v.i = i;
     
106.     return v.f;
     
107. }
     
108. 
     
109. /*
     
110.  * get_header_audio check if the flv have audio stream
     
111.  * info, a byte with video and audio bit flag
     
112.  *
     
113.  * return 0 or 1
     
114. */
     
115. int get_header_audio(char info)
     
116. {
     
117.     return (info & 0x4) >> 2;
     
118. }
     
119. 
     
120. /*
     
121.  * get_header_video check if the flv have video stream
     
122.  * info, a byte with video and audio bit flag
     
123.  *
     
124.  * return 0 or 1
     
125. */
     
126. int get_header_video(char info)
     
127. {
     
128.     return info & 0x1;
     
129. }
     
130. 
     
131. /*
     
132.  * flv_header_parse just parse the FLV VERSION tag
     
133.  * fd, file describe handle
     
134.  * return flv version
     
135. */
     
136. int flv_header_parse(int fd)
     
137. {
     
138.     int ret = 0;
     
139.     header_t header;
     
140. 
     
141.     memset(&header, 0, sizeof(header));
     
142.     ret = read(fd, &header, sizeof(header));
     
143.     if (ret <= 0) {
     
144.         fprintf(stderr, "read header error, %d\n", -EINVAL);
     
145.         return -EINVAL;
     
146.     }
     
147. 
     
148. 
     
149.     fprintf(stdout, "flv = [%c %c %c] version = [%x]\n"
     
150.             "TypeFlagsAudio = [%x], TypeFlagsVideo = [%x], DataOffset = [%x %x %x %x]\n",
     
151.             header.tag_f, header.tag_l, header.tag_v, header.version,
     
152.             get_header_audio(header.audio_and_video), get_header_video(header.audio_and_video),
     
153.             header.DataOffset[0], header.DataOffset[1], header.DataOffset[2], header.DataOffset[3]);
     
154. 
     
155.     return (int)header.version;
     
156. }
     
157. 
     
158. 
     
159. /*
     
160.  * flv_do_tag just parse all the flv tag
     
161.  * fd, file describe handle
     
162.  * size, the size of the flv tag body
     
163.  *
     
164.  * return tag type
     
165. */
     
166. int flv_do_tag(int fd, unsigned long *size)
     
167. {
     
168.     int ret = 0;
     
169.     char *p = NULL;
     
170.     char data_size[11] = {0};
     
171.     body_t body;
     
172. 
     
173. 
     
174.     ret = read(fd, &body, sizeof(body));
     
175.     if (ret <= 0) {
     
176.         fprintf(stderr, "Can not ret the fd errno [%d]\n", -EINVAL);
     
177.         return -EINVAL;
     
178.     }
     
179. 
     
180.     fprintf(stdout, "size = %lu tag->type = [%x]"
     
181.             "tag->size = [%0.2x %0.2x %0.2x], tag->timestamp = [%0.2x %0.2x %0.2x], "
     
182.             "tag->extent_timestamp = [%0.2x], tag->streamid = [%0.2x %0.2x %0.2x]\n",
     
183.             sizeof(body), body.tag.tagtype,
     
184.             body.tag.size[0], body.tag.size[1],body.tag.size[2], body.tag.timestamp[0], body.tag.timestamp[1],
     
185.             body.tag.timestamp[2], body.tag.extent_timestamp, body.tag.stream_id[0],
     
186.             body.tag.stream_id[1], body.tag.stream_id[2]);
     
187.     memcpy(data_size, body.tag.size, 3);
     
188.     p = data_size;
     
189.     snprintf(data_size, sizeof(data_size), "0x%x%x%x", body.tag.size[0], body.tag.size[1], body.tag.size[2]);
     
190.     *size = strtoul(p, NULL, 16);
     
191.     fprintf(stdout, "size = [%lu] \n", *size);
     
192. 
     
193.     return body.tag.tagtype;
     
194. }
     
195. 
     
196. /*
     
197.  * get_string_len get the key-value value string length
     
198.  * data, the data will be parsed
     
199.  *
     
200.  * return the String length by int
     
201. */
     
202. int get_string_len(unsigned char *data)
     
203. {
     
204. 
     
205.     unsigned char *p = data;
     
206.     unsigned char len_char[8];
     
207.     int len_int = 0;
     
208. 
     
209.     memset(len_char, 0, sizeof(len_char));
     
210.     snprintf((char *)len_char, sizeof(len_char), "0x%x%x", data[0], data[1]);
     
211.     p = len_char;
     
212. 
     
213.     len_int = strtoul((char *)p, NULL, 16);
     
214. 
     
215.     return len_int;
     
216. }
     
217. 
     
218. /*
     
219.  * get_bool_value get bool type value (key-value value)
     
220.  * data, the data will be parsed
     
221.  *
     
222.  * return bool value 0 or 1
     
223. */
     
224. int get_bool_value(unsigned char *data)
     
225. {
     
226.    return *data;
     
227. }
     
228. 
     
229. /*
     
230.  * get_key_len the key-value key string length unit: four bytes
     
231.  * data, the data will be parsed
     
232.  *
     
233.  * return the key length by int
     
234. */
     
235. int get_key_len(unsigned char *data)
     
236. {
     
237.     char len_char[16];
     
238.     char *p = len_char;
     
239. 
     
240.     memset(len_char, 0, sizeof(len_char));
     
241.     snprintf(len_char, sizeof(len_char), "0x%x%x%x%x", data[0], data[1], data[2], data[3]);
     
242. 
     
243.     return strtoul(p, NULL, 16);
     
244. }
     
245. 
     
246. int process_ecma_array_end(unsigned char *data)
     
247. {
     
248.     return 0;
     
249. }
     
250. 
     
251. /*
     
252.  * process_ecma_array The onMetaData sub type named ECMA Array
     
253.  * data, the data will be parsed
     
254.  *
     
255.  * return the offset of the data
     
256. */
     
257. int process_ecma_array(unsigned char *data)
     
258. {
     
259.     int ecma_array_len = 0;
     
260.     int keyname_len = 0;
     
261.     unsigned char keyname[32];
     
262.     unsigned char *p = data;
     
263.     int i = 0;
     
264. 
     
265.     ecma_array_len = get_key_len(p);
     
266.     p += 4;
     
267. 
     
268.     for (i = 0; i < ecma_array_len; i++) {
     
269.         keyname_len = get_string_len(p);
     
270.         p += 2;
     
271.         memset(keyname, 0, sizeof(keyname));
     
272.         strncpy((char *)keyname, (const char *)p, keyname_len);
     
273.         fprintf(stdout, "keyname = [%s]\n", keyname);
     
274.         p += keyname_len;
     
275.         p += script_type_parse(p);
     
276.     }
     
277. 
     
278.     if (*p == 0 && *(p + 1) == 0 && *(p + 2) == 9) {
     
279.         p += 3;
     
280.     }
     
281.     return p - data;
     
282. }
     
283. 
     
284. /*
     
285.  * get_double get the double number by long long type
     
286.  * data, the data will be parsed
     
287.  *
     
288.  * return the parse out number of long long
     
289. */
     
290. unsigned long long get_double(unsigned char *data)
     
291. {
     
292.     unsigned char double_number[64];
     
293.     unsigned char *p = double_number;
     
294. 
     
295.     memset(double_number, 0, sizeof(double_number));
     
296.     snprintf((char *)double_number, sizeof(double_number), "0x%0.2x%0.2x%0.2x%0.2x%0.2x%0.2x%0.2x%0.2x",
     
297.              *data, *(data + 1), *(data + 2), *(data + 3), *(data + 4), *(data + 5), *(data + 6), *(data + 7));
     
298. 
     
299.     return strtoull((char *)p, NULL, 16);
     
300. 
     
301. }
     
302. 
     
303. /*
     
304.  * script_type_parse parse the script object type and parse the data
     
305.  * data, the data will be parsed
     
306.  *
     
307.  * return the data offset
     
308. */
     
309. int script_type_parse(unsigned char *data)
     
310. {
     
311.     int ret = 0;
     
312.     unsigned char *p = data;
     
313.     unsigned char string_output[512];
     
314.     unsigned long long number = 0;
     
315.     double double_number = 0.0;
     
316. 
     
317.     switch (*p) {
     
318.     case Number:
     
319.         p++;
     
320.         number = get_double(p);
     
321.         double_number = int2double(number);
     
322.         fprintf(stdout, "number = [%.2f]\n", double_number);
     
323.         p += 8;
     
324.         break;
     
325. 
     
326.     case Boolean:
     
327.         p++;
     
328.         ret = get_bool_value(p);
     
329.         p++;
     
330.         break;
     
331. 
     
332.     case String:
     
333.         p++;
     
334.         memset(string_output, 0, sizeof(string_output));
     
335.         ret = get_string_len(p);
     
336.         p += 2;
     
337.         strncpy((char *)string_output, (const char *)p, ret);
     
338.         fprintf(stdout, "String = [%s]\n", string_output);
     
339.         p += ret;
     
340.         break;
     
341. 
     
342.     case Object:
     
343.         p++;
     
344.         break;
     
345. 
     
346.     case MovieClip:
     
347.         p++;
     
348.         break;
     
349. 
     
350.     case Null:
     
351.         p++;
     
352.         break;
     
353. 
     
354.     case Undefined:
     
355.         p++;
     
356.         break;
     
357. 
     
358.     case Reference:
     
359.         p++;
     
360.         break;
     
361. 
     
362.     case EcmaArray:
     
363.         p++;
     
364.         ret = process_ecma_array(p);
     
365.         p += ret;
     
366.         break;
     
367. 
     
368.     case ObjectEndMarker:
     
369.         p++;
     
370.         break;
     
371. 
     
372.     case StringArray:
     
373.         p++;
     
374.         break;
     
375. 
     
376.     case Date:
     
377.         p++;
     
378.         break;
     
379. 
     
380.     case LongString:
     
381.         p++;
     
382.         break;
     
383. 
     
384.     default:
     
385. 
     
386.         break;
     
387.     }
     
388.     return p - data;
     
389. }
     
390. 
     
391. /*
     
392.  * do_tag_onMetaData parse the onMetaData tags
     
393.  * fd, file describe handle
     
394.  * size, will read size of the data, unit: byte
     
395.  *
     
396.  * return offset of the data
     
397. */
     
398. int do_tag_onMetaData(int fd, int size)
     
399. {
     
400.     int ret = 0;
     
401.     unsigned char *p = NULL;
     
402. 
     
403.     unsigned char *onMetaData = malloc(size);
     
404.     fprintf(stdout, "size = [%d]\n", size);
     
405.     memset(onMetaData, 0, size);
     
406.     ret = read(fd, onMetaData, size);
     
407.     fprintf(stdout, "ret = [%d]\n", ret);
     
408. 
     
409.     int fuck = open("./xxx.dat", O_RDWR);
     
410.     write(fuck, onMetaData, ret);
     
411.     close(fuck);
     
412.     p = onMetaData;
     
413. 
     
414.     while (p) {
     
415.         if (p - onMetaData >= size) {
     
416.             break;
     
417.         }
     
418.         ret = script_type_parse(p);
     
419.         fprintf(stdout, "in while 1 offset = [%d]\n", p - onMetaData);
     
420.         p += ret;
     
421.     }
     
422.     return p - onMetaData;
     
423. }
     
424. 
     
425. /*
     
426.  * dump_flv_info just print the flv onMetaData info
     
427.  * filename, the flv filename
     
428.  *
     
429.  * return always right
     
430. */
     
431. int dump_flv_info(char *filename)
     
432. {
     
433.     int fd = 0;
     
434.     int tag_type = -1;
     
435.     int ret = 0;
     
436.     unsigned long size = 0;
     
437.     unsigned char PreviousTagSize[4];
     
438. 
     
439.     fd = open(filename, O_RDONLY);
     
440.     if (fd < 0) {
     
441.         fprintf(stdout, "Can not open the file [%s]\n", filename);
     
442.         return -ENOENT;
     
443.     }
     
444.     fprintf(stdout, "filename = [%s]\n", filename);
     
445. 
     
446.     flv_header_parse(fd);
     
447.     ret = read(fd, PreviousTagSize, sizeof(PreviousTagSize));
     
448.     tag_type = flv_do_tag(fd, &size);
     
449. 
     
450.     switch(tag_type) {
     
451.     case TAG_TYPE_SCRIPTDATA:
     
452.         fprintf(stdout, "data_size = [%lu]\n", size);
     
453.         do_tag_onMetaData(fd, size);
     
454. 
     
455.         break;
     
456.     }
     
457.     return 0;
     
458. }
     
459. 
     
460. void usage(char **argv)
     
461. {
     
462.     fprintf(stderr, "Usage:\n"
     
463.             "\t%s flv_file_name\n", argv[0]);
     
464.     return ;
     
465. }
     
466. 
     
467. int main(int argc, char *argv[])
     
468. {
     
469.     char *filename = NULL;
     
470. 
     
471.     if (argc < 2) {
     
472.         usage(argv);
     
473.         return -EINVAL;
     
474.     }
     
475. 
     
476.     filename = argv[1];
     
477. 
     
478.     dump_flv_info(filename);
     
479.     return 0;
     
480. }

Makefile为

点击(此处)折叠或打开

1. all:
   
2.     gcc -O2 -Wall -g dump_flv_info.c -o flv_info
   
3. 
   
4. clean:
   
5.     rm -rf flv_info

执行结果如下：

2.flv的内容：

主要参考文档为：
video_file_format_spec_v10_1_20131118111845.pdf

根据参考文档可以看出来

解析步骤如下

首先解析文件头

根据上面的内容可以看出来，FLV和Version占用了4个字节，而Version总是1,其中的DataOffset一般来在flv的version是1的时候总是9，如图

464c 5601为四个字节，就是FLV 和Version部分，接下来的05为一个字节，这个字节为TypeFlagsReserved, TypeFlagsAudio,TyopeFlagsReserved, TypeFlagsVideo的内容，可以将05转换为2进制，就是00000101, 也就是video是1，audio也是1，接下爱就是DataOffset，DataOffset一次读取32位，就是4个字节，内容为00 0000 09，也就是上面参考中的内容，The DataOffset field usually has a value of 9；

接下来就开始解析FLV的File Body:

部分，这部分排列方式位PreviousTagSizeN（N >= 0）,如图

占用了4个字节，全部为0.在前面的spec里面可以看到，接下来的就是FLVTAG，这个FLVTAG为另外一个结构，结构如下：

通过结构可以看出，Reserved,Filter,TagType占用了一个字节，也就是前面的12，这里说的12其实不是十进制的12，而是16进制的0x12，将其转成十进制就是18，可以转成2进制进行对比，最终TagType来判断这个FLVTAG是音频，还是视频，还是脚本数据(ScriptData)，如果TagType是8就是audio，如果TagType是9就是video，如果TagType是18，就是ScriptData；接下来继续读取24个字节，来判断将要读取得FLVTAG对应的数据字节数，例如onMetaData这部分是ScriptData，那么读取ScriptData的数据的时候，就要读取DataSize这么大，如图：

可以看到，需要读取0x000125这么多数据，转换成十进制的话，就是293个字节的数据，这个数据我们暂且记下，后面会用到，千万要记住！！！

接下来就是读取TimeStamp（3个字节）和Extent Timestamp（1个字节），两个字段加起来，占用了4个字节，全部为0，具体参考上(孙悟空 http://bbs.chinaffmpeg.com)面的spec可以看到为什么，过了四个字节以后，进入到StreamID部分，StreamID占用了3个字节，总是0，Spec中已经可以看到，接下来就是0200 0a6f ....部分，这部分在前面的spec中可以看到说明，由于前面我们看到的是TagType是18，那么这个地方就做ScriptData相关的处理办法，直接按照ScriptData来处理：

从上面spec中可以看到，ScriptData里面使用了ScriptTagBody，而ScriptTagBody的定义为一个Type和ScriptDataValue，其中的DataValue是根据Type来决定的，我们读数据读到offset为0x0000010 + 8位置，这时下一个字节为02,也就是说，Type为SCRIPTDATASTRING，这个时候会处理SCRIPTDATASTRING,

SCRIPTDATASTRING份两部分，一个是2两个字节的StringLength，一个是StringData，这个StringData部分占用的字节多少由StringLength部分决定，那么就继续上面的位置读取2字节，为00 0a,然后接下来读取00 0a个字节，作为String内容，也就是看到的onMetaData这个字符串，这样，onMetaData这个字符串读取 (孙悟空 http://bbs.chinaffmpeg.com) 完毕，也就是前面提到的ScriptTagBody的Name部分读取完毕。接下来内容进入到了高潮：读取ECMA ARRAY部分，同样使用前面的办法读取对应的内容，如图：

其中08为ECMAARRAY的类型，接下来的0000 000d为ECMAARRAY中的结构的ECMAArrayLength，一次读取4个字节，得到的结果为13(0x0d)。

也就是说，ECMAARRAY由13个对应的项，可以建立一个递归或者循环，去读取这13个Variables，接下来开始解析第一个Variable，也就是SCRIPTDATAOBJECTPROPERTY。

接下来就是解析PropertyName，也是SCRIPTDATASTRING类型，对应解析办法前面有提到过，一次读两个字节，然后获得PropertyName的字符串，然后获得对应的PropertyData数据，要注意的是PropertyData里面的数据类型，读到的是00的话，就是Number方法，这个Number存的值就是个DOUBLE,通过前 (孙悟空 http://bbs.chinaffmpeg.com) 面的spec参考可以看到对应的信息，下图是对应的字节：

接下来可以按照前面的方法继续循环或者递归，这样，就将onMetaData信息全部读取出来了，读取最后的时候不要忘记有三个字节，0000 09,为SCRIPTDATAOBJECTEND，

这样，FLV的onMetaData部分解析完毕