1.修改命名为av_format_identify.h与av_format_identify.c

2.头文件av_format_identify.h中仅保留供调用者查看的函数定义
3.添加.gitignore用以排除特定文件类型(.a,.o)的上传
4.将视频封装格式判断函数AV_container_identify返回数值与类型对应的宏顶一顶到AV_container_identify.h中
5.修改is_mp4_part_boxtype为is_mp4_boxtype,修改is_mp4_part_4char为is_mp4_boxname
6.取消函数char_is_mp4，将其以for循环的形式直接放入is_mp4_boxname中
7.将计数型变量fit_times初始化由1变为0并改变其与对应上限值FIT_TIMES的关系比较运算符>为>=
8.在is_mp4_each中，修改fit_times >= FIT_TIMES + 1为fit_times > FIT_TIMES
8.全局变量设置为以"g_"开头的形式,且保证变量名命名清晰,mp4_box_type_all变为p_mp4_box_type_all,count_type变为g_mp4_box_type_count.同时将g_mp4_box_type_count设置为const int.
9.将所有数值变量定义为宏，包括#define TS_SYNC_BYTE 0x47, #define TS_PKT_SIZE 188, #define FLV_TAG_AUDIO 0x08, #define FLV_TAG_VIDEO 0x09, #define FLV_TAG_SCRIPT_DATA 0x12
10.修改is_mpeg_ts_each函数:Continuity counter的变化是针对PID的,且PID为8191时除外；
11.修改is_mpeg_ts_each函数:为防止其他封装格式视频内会出现部分形似ts package情况，将条件进一步严苛至特定查找未来188倍数的字节是否为0x47，倍数的选择为剩余字节流长度除以188取整的数目及其半数与四分之一数的取整
12.修改is_mp4_each函数，加入对mdat box可能出现的largesize情况的考虑。

17 files changed, 468 insertions, 392 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b9e4d17
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+__view
+*.o
+*.so
+*.a
diff --git a/bin/test b/bin/test
index 09ea650..801cec6 100644
--- a/bin/test
+++ b/bin/test
diff --git a/bin/test_dir b/bin/test_dir
index c31057d..ef2c7d5 100644
--- a/bin/test_dir
+++ b/bin/test_dir
diff --git a/inc/vdefine.h b/inc/av_format_identify.h
index 7e10e54..132cb8b 100644
--- a/inc/vdefine.h
+++ b/inc/av_format_identify.h
@@ -1,12 +1,11 @@
-#ifndef _VDEFINE_H
-#define _VDEFINE_H
+#ifndef _AV_FORMAT_IDENTIFY_H
+#define _AV_FORMAT_IDENTIFY_H
 
 #include <arpa/inet.h>
 #include <stdlib.h>
-#define _GNU_SOURCE
-#define __USE_GNU
 #include <string.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <math.h>
 #include <sys/types.h>  
 
@@ -14,8 +13,10 @@
 
 #include <arpa/inet.h>
 
-extern const char *mp4_box_type_all[];
-extern int count_type;
+#define AV_CONTAINER_MPEGTS	1
+#define AV_CONTAINER_FLV	2
+#define AV_CONTAINER_MP4	3
+#define UNKNOWN 4
 
 /*To find that whether the initial size bytes pointed to by buff satisfies the rules of MPEG-TS AV Container
  * by supposing that its first 1 byte is sync_byte in ts header.*/
@@ -23,29 +24,20 @@ int is_mpeg_ts_each(const char *buff, size_t size);
 /*To identify whether the whole byte stream belongs to MPEG_TS container*/
 int is_mpeg_ts(const char* buff, size_t size);
 
-/*Scanning the initial size bytes of the memory area pointed to by buff for the first instance of 0x08, 0x09 or 0x12*/
-void *memchr_flv(const char *buff, size_t size);
+
 /*To find that whether the initial size bytes pointed to by buff satisfies the rules of FLV AV Container
  * by supposing that its first 1 byte is TagType in FLV Tag Header.*/
 int is_flv_each(const char* buff, size_t size);
 /*To identify whether the whole byte stream belongs to FLV container*/
 int is_flv(const char* buff, size_t size);
 
-/*whether the initial several bytes of the memory area pointed to by buff_part is one kind of Boxtype of MP4 file*/
-int is_mp4_part_boxtype(const char *buff);
-/*whether one byte is number or lower case*/
-int char_is_mp4(char c);
-/*whether all of those initial 4 bytes of the memory area pointed to by buff are number or lower case */
-int is_mp4_part_4char(const char *buff);
-/*Scanning the initial size bytes of the memory area pointed to by buff for the first instance of continuous 4 bytes of number or lower case*/
-void *memmem_mp4(const char *buff, size_t size);
 /*To find that whether the initial size bytes pointed to by buff satisfies the rules of MP4 AV Container
  * by supposing that its first 4 byte is Boxtype in Box of MP4 file.*/
 int is_mp4_each(const char* buff, size_t size);
 /*To identify whether the whole byte stream belongs to MP4 container*/
 int is_mp4(const char* buff, size_t size);
 
+/*To identify the container type of the whole byte stream*/
 int AV_container_identify(const char* buff, size_t size);
 
-
 #endif
diff --git a/lib/.gitignore b/lib/.gitignore
new file mode 100644
index 0000000..b9e4d17
--- /dev/null
+++ b/lib/.gitignore
@@ -0,0 +1,4 @@
+__view
+*.o
+*.so
+*.a
diff --git a/lib/libvdefine.a b/lib/libvdefine.a
deleted file mode 100644
index f827ef3..0000000
--- a/lib/libvdefine.a
+++ /dev/null
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..b9e4d17
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,4 @@
+__view
+*.o
+*.so
+*.a
diff --git a/src/Makefile b/src/Makefile
index 8d22255..593f286 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,6 +1,6 @@
-SOURCE = vdefine.c
-OBJS = vdefine.o
-TARGET = libvdefine.a
+SOURCE = av_format_identify.c
+OBJS = av_format_identify.o
+TARGET = libav_format_identify.a
 
 CC = gcc
 CFLAGS = -g
@@ -11,8 +11,8 @@ all:$(TARGET)
 .c.o:
 	$(CC) -c $(CFLAGS) -I$(INC_PATH) $<
 
-libvdefine.a: $(OBJS)
-	(rm -rf $@; ar -r $@ $^; cp $@ $(LIB_PATH);)
+$(TARGET): $(OBJS)
+	(rm -f $@; ar -r $@ $^; cp -f $@ $(LIB_PATH);)
 
 clean:
 	rm -f *.o $(TARGET)
diff --git a/src/av_format_identify.c b/src/av_format_identify.c
new file mode 100644
index 0000000..72ac53c
--- /dev/null
+++ b/src/av_format_identify.c
@@ -0,0 +1,429 @@
+#include <arpa/inet.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <math.h>
+#include <sys/types.h>  
+#include <sys/io.h>
+#include <arpa/inet.h>
+
+
+#define FIT_TIMES 1
+#define TS_SYNC_BYTE 0x47
+#define TS_PKT_SIZE 188
+#define FLV_TAG_AUDIO 0x08
+#define FLV_TAG_VIDEO 0x09
+#define FLV_TAG_SCRIPT_DATA 0x12
+
+#include "av_format_identify.h"
+
+
+const char *g_mp4_box_type_all[] = { "ftyp", "pdin", "moov", "mvhd", "trak", "tkhd", "tref", "edts", "elst", "mdia", "mdhd",
+"hdlr", "minf", "vmhd", "smhd", "hmhd", "nmhd", "dinf", "dref", "stbl", "stsd", "stts", "ctts", "stsc", "stsz",
+"stz2", "stco", "co64", "stss", "stsh", "padb", "stdp", "sdtp", "sbgp", "sgpd", "subs", "mvex", "mehd", "trex",
+"ipmc", "moof", "mfhd", "traf", "tfhd", "trun", "sdtp", "sbgp", "subs", "mfra", "tfra", "mfro", "mdat", "free",
+"skip", "udta", "cprt", "meta", "hdlr", "dinf", "dref", "ipmc", "iloc", "ipro", "sinf", "frma", "imif", "schm",
+"schi", "iinf", "xml", "bxml", "pitm", "fiin", "paen", "fpar", "fecr", "segr", "gitn", "tsel", "meco", "mere", "uuid" };
+const int g_mp4_box_type_count = sizeof(g_mp4_box_type_all) / sizeof(char *);
+
+
+int is_mpeg_ts_each(const char *buff, size_t size)
+{
+	int ret_ts_each = 0;
+	const char *p = buff;
+	int fit_times = 0;
+	p += TS_PKT_SIZE;
+
+	size_t  cont_cout_pre, cont_cout_aft;
+	cont_cout_pre = htonl(*(size_t *)buff) & 0x0000000f;
+
+    uint32_t pid_pre, pid_aft;
+    pid_pre = ((htonl(*(uint32_t *)buff) & 0x000fff00) >> 8) + ((((htonl(*(uint32_t *)buff) & 0x00f00000) >> 20) % 2) << 12);
+
+	while (p < (buff + size))
+	{
+		if (*p == TS_SYNC_BYTE)
+		{
+			if ((p + 3) < (buff + size))
+			{
+                pid_aft = ((htonl(*(uint32_t *)p) & 0x000fff00) >> 8) + ((((htonl(*(uint32_t *)p) & 0x00f00000) >> 20) % 2) << 12);
+                if (pid_aft == pid_pre && pid_aft!=8191)
+                {
+                	cont_cout_aft = htonl(*(size_t *)p) & 0x0000000f;
+				    if (cont_cout_aft == (cont_cout_pre + 1) % 16)
+				    {
+					    fit_times++;
+				    }
+				    else
+				    {
+					    break;
+				    }
+                }
+                else
+                {
+                    fit_times++;
+                }
+			}
+			if (fit_times >= FIT_TIMES)
+			{
+				size_t whole_pack_cout = size / TS_PKT_SIZE;
+				if (size % TS_PKT_SIZE == 0)
+				{
+					whole_pack_cout--;
+				}
+                size_t half_pack_cout = whole_pack_cout/2;
+                size_t quarter_pack_cout = whole_pack_cout/4;
+                if (whole_pack_cout < 3 || half_pack_cout < 2 || quarter_pack_cout < 1)
+                {
+                    break;
+                }
+				const char *pack_tail = buff + whole_pack_cout * TS_PKT_SIZE;
+                const char *pack_half = buff + half_pack_cout * TS_PKT_SIZE;
+				const char *pack_quarter = buff + quarter_pack_cout * TS_PKT_SIZE;
+                //if (*pack_tail == TS_SYNC_BYTE && *(pack_tail - TS_PKT_SIZE) == TS_SYNC_BYTE)
+                if (*pack_tail == TS_SYNC_BYTE && *pack_half == TS_SYNC_BYTE && *pack_quarter == TS_SYNC_BYTE)
+				{
+					ret_ts_each = 1;
+					break;
+				}
+				break;
+			}
+		}
+		else
+		{
+			break;
+		}
+
+		cont_cout_pre = cont_cout_aft;
+		pid_pre = pid_aft;
+        p += TS_PKT_SIZE;
+	}
+	return ret_ts_each;
+}
+
+int is_mpeg_ts(const char* buff, size_t size)
+{
+	int ret_ts = 0;
+	const char *p_each = buff;
+	int ret_ts_each;
+	while (p_each < buff + size)
+	{
+		p_each = memchr(p_each, TS_SYNC_BYTE, size - (p_each - buff));
+		if (p_each == NULL)
+		{
+			break;
+		}
+		else if (p_each + 3 >= buff + size)
+		{
+			break;
+		}
+		else
+		{
+			ret_ts_each = is_mpeg_ts_each(p_each, size - (p_each - buff));
+			if (ret_ts_each == 1)
+			{
+				ret_ts = 1;
+				break;
+			}
+			p_each++;
+		}
+	}
+	return ret_ts;
+}
+
+
+void *memchr_flv(const char *buff, size_t size)
+{
+	void *ret_memflv = NULL;
+	const char *p = buff;
+	while (p < buff + size)
+	{
+		if (*p == FLV_TAG_AUDIO || *p == FLV_TAG_VIDEO || *p == FLV_TAG_SCRIPT_DATA)
+		{
+			ret_memflv = (void *)p;
+			break;
+		}
+		p++;
+	}
+	return ret_memflv;
+}
+
+int is_flv_each(const char* buff, size_t size)
+{
+	int ret_flv_each = 0;
+	const char *p = buff;
+	int fit_times = 0;
+	size_t left;
+	size_t right = 11 + htonl(*(size_t *)p) & 0x00ffffff;
+	p += (right + 4);
+
+	while (p < (buff + size))
+	{
+		left = htonl(*(size_t *)(p - 4));
+		if (right == left && (*(p) == FLV_TAG_AUDIO || *(p) == FLV_TAG_VIDEO || *(p) == FLV_TAG_SCRIPT_DATA))
+		{
+			fit_times++;
+			if (fit_times >= FIT_TIMES)
+			{
+				ret_flv_each = 1;
+				break;
+			}
+		}
+		else
+		{
+			break;
+		}
+		if ((p + 3) >= (buff + size))
+		{
+			break;
+		}
+		right = 11 + htonl(*(size_t *)p) & 0x00ffffff;
+		p += (right + 4);
+	}
+	return ret_flv_each;
+}
+
+int is_flv(const char* buff, size_t size)
+{
+	int ret_flv = 0;
+	int ret_flv_each;
+	const char *p_each = buff;
+
+	while (p_each < size + buff)
+	{
+		p_each = memchr_flv(p_each, size - (p_each - buff));
+		if (p_each == NULL)
+		{
+			break;
+		}
+		else if (p_each + 3 >= buff + size)
+		{
+			break;
+		}
+		else
+		{
+			ret_flv_each = is_flv_each(p_each, size - (p_each - buff));
+			if (ret_flv_each == 1)
+			{
+				ret_flv = 1;
+				break;
+			}
+			p_each++;
+		}
+	}
+	return ret_flv;
+}
+
+
+
+int is_mp4_boxtype(const char *buff)
+{
+	int i;
+	size_t size_type_h;
+	for (i = 0; i < g_mp4_box_type_count; i++)
+	{
+		size_type_h = strlen(g_mp4_box_type_all[i]);
+		if (memcmp(buff, g_mp4_box_type_all[i], size_type_h) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+
+
+int is_mp4_boxname(const char *buff)
+{
+	int i;
+	for (i = 0; i < 4; i++)
+	{
+		if (*(buff + i) < '0' || *(buff + i) > '9'&&*(buff + i) < 'a' || *(buff + i) > 'z')
+		{
+			return 0;
+		}
+	}
+	return 1;
+}
+
+void *memmem_mp4(const char *buff, size_t size)
+{
+	void *ret_memmp4 = NULL;
+	char s;
+	const char *p = buff;
+	while (p + 3 < buff + size)
+	{
+		if (is_mp4_boxname(p) == 1)
+		{
+			ret_memmp4 = (void *)p;
+			break;
+		}
+		p++;
+	}
+	return ret_memmp4;
+}
+
+int is_mp4_each(const char* buff, size_t size)
+{
+	int ret_mp4_each = 0;
+	int ret_mp4_boxname;
+	int sig_mp4_boxtype = 0;
+	if (is_mp4_boxtype(buff) == 1)
+	{
+		sig_mp4_boxtype = 1;
+	}
+	const char *p = buff;
+	int fit_times = 0;
+
+	size_t size_h;
+	p += 8;
+	while (p + 4 < (buff + size))
+	{
+		if (memcmp(p - 8, "mdat", 4) == 0 && htonl(*(size_t *)(p - 12)) == 1)
+		{
+			p -= 8;
+			if (p + 12 < buff + size)
+			{
+				size_h = htonl(*(size_t *)(p + 4));
+				size_h = (size_h<<32)+ htonl(*(size_t *)(p + 8));
+				p += size_h;
+				if (p + 4 < buff + size)
+				{
+					ret_mp4_boxname = is_mp4_boxname(p);
+					if (!is_mp4_boxname)
+					{
+						p -= size_h;
+						if (p + 16 < buff + size)
+						{
+							size_h = htonl(*(size_t *)(p + 8));
+							size_h = (size_h << 32) + htonl(*(size_t *)(p + 12));
+							p += size_h;
+							if (p + 4 < buff + size)
+							{
+								ret_mp4_boxname = is_mp4_boxname(p);
+								if (!is_mp4_boxname)
+								{
+									p -= size_h;
+								}
+							}
+                            else
+                            {
+                                    break;
+                            }
+
+						}
+                        else
+                        {
+                                break;
+                        }
+
+					}
+				}
+                else
+                {
+                        break;
+                }
+
+			}
+            else
+            {
+                break;
+            }
+		}
+		else
+		{
+			ret_mp4_boxname = is_mp4_boxname(p);
+			if (!ret_mp4_boxname)
+			{
+				p -= 8;
+				size_h = htonl(*(size_t *)(p - 4));
+				p += size_h;
+				if (p + 4 < buff + size)
+				{
+					ret_mp4_boxname = is_mp4_boxname(p);
+					if (!ret_mp4_boxname)
+					{
+						break;
+					}
+				}
+                else
+                {
+                    break;
+                }
+			}
+		}
+		fit_times++;
+		if (is_mp4_boxtype(p) == 1)
+		{
+			sig_mp4_boxtype++;
+		}
+		if (fit_times >= FIT_TIMES && sig_mp4_boxtype >= 1)
+		{
+			ret_mp4_each = 1;
+			break;
+		}
+		if (fit_times > FIT_TIMES)
+		{
+			break;
+		}
+		
+		p += 8;
+	}
+	return ret_mp4_each;
+}
+
+
+int is_mp4(const char* buff, size_t size)
+{
+	int ret_mp4 = 0;
+	int ret_mp4_each;
+	const char *p_each = buff;
+
+	while (p_each < buff + size)
+	{
+		p_each = (const char *)memmem_mp4(p_each, size - (p_each - buff));
+		if (p_each == NULL)
+		{
+			break;
+		}
+		else if (p_each + 12 >= buff + size)
+		{
+			break;
+		}
+		else if (p_each - 4 < buff)
+		{
+			p_each++;
+			continue;
+		}
+		else
+		{
+			ret_mp4_each = is_mp4_each(p_each, size - (p_each - buff));
+			if (ret_mp4_each == 1)
+			{
+				ret_mp4 = 1;
+				break;
+			}
+			p_each++;
+		}
+	}
+	return ret_mp4;
+}
+
+int AV_container_identify(const char* buff, size_t size)
+{
+	if (1 == is_mpeg_ts(buff, size))
+	{
+		return AV_CONTAINER_MPEGTS;
+	}
+	if (1 == is_flv(buff, size))
+	{
+		return AV_CONTAINER_FLV;
+	}
+	if (1 == is_mp4(buff, size))
+	{
+		return AV_CONTAINER_MP4;
+	}
+	return UNKNOWN;
+}
+
+
+
diff --git a/src/libvdefine.a b/src/libvdefine.a
deleted file mode 100644
index f827ef3..0000000
--- a/src/libvdefine.a
+++ /dev/null
diff --git a/src/vdefine.c b/src/vdefine.c
deleted file mode 100644
index 2472758..0000000
--- a/src/vdefine.c
+++ /dev/null
@@ -1,360 +0,0 @@
-
-#define AV_CONTAINER_MPEGTS	1
-#define AV_CONTAINER_FLV	2
-#define AV_CONTAINER_MP4	3
-#define UNKNOWN 4
-#define FIT_TIMES 1
-#define MAX_FLV_FRAME max_flv_frame;
-
-#include "vdefine.h"
-
-const char *mp4_box_type_all[] = { "ftyp", "pdin", "moov", "mvhd", "trak", "tkhd", "tref", "edts", "elst", "mdia", "mdhd",
-        "hdlr", "minf", "vmhd", "smhd", "hmhd", "nmhd", "dinf", "dref", "stbl", "stsd", "stts", "ctts", "stsc", "stsz",
-        "stz2", "stco", "co64", "stss", "stsh", "padb", "stdp", "sdtp", "sbgp", "sgpd", "subs", "mvex", "mehd", "trex",
-        "ipmc", "moof", "mfhd", "traf", "tfhd", "trun", "sdtp", "sbgp", "subs", "mfra", "tfra", "mfro", "mdat", "free",
-        "skip", "udta", "cprt", "meta", "hdlr", "dinf", "dref", "ipmc", "iloc", "ipro", "sinf", "frma", "imif", "schm",
-        "schi", "iinf", "xml", "bxml", "pitm", "fiin", "paen", "fpar", "fecr", "segr", "gitn", "tsel", "meco", "mere" };
-int count_type = sizeof(mp4_box_type_all) / sizeof(char *);
-
-
-int is_mpeg_ts_each(const char *buff, size_t size)
-{
-        int ret_ts_each = 0;
-        const char *p = buff;
-        int fit_times = 1;
-        p += 188;
-
-        size_t cont_cout_ori, cont_cout_end, cont_cout_pre, cont_cout_aft;
-        cont_cout_ori = htonl(*(size_t *)buff) & 0x0000000f;
-        cont_cout_pre = cont_cout_ori;
-        while (p < (buff + size))
-        {
-                if (*p == 0x47)
-                {
-                        if ((p + 3) < (buff + size))
-                        {
-                                cont_cout_aft = htonl(*(size_t *)p) & 0x0000000f;
-                                if (cont_cout_aft == (cont_cout_pre + 1) % 16)
-                                {
-                                        fit_times++;
-                                }
-                                else
-                                {
-                                        break;
-                                }
-                        }
-                        if (fit_times > FIT_TIMES)
-                        {
-                                size_t whole_pack_cout = size / 188;
-                                if (size % 188 == 0)
-                                {
-                                        whole_pack_cout--;
-                                }
-                                size_t whole_pack_bites = whole_pack_cout * 188;
-                                const char *pack_tail = buff + whole_pack_bites;
-                                if (*pack_tail == 0x47 && *(pack_tail-188) == 0x47)
-                                {
-                                        ret_ts_each = 1;
-                                        break;
-                                }
-                                break;
-                        }
-                }
-                else
-                {
-                        break;
-                }
-
-                cont_cout_pre = cont_cout_aft;
-                p += 188;
-        }
-        return ret_ts_each;
-}
-
-int is_mpeg_ts(const char* buff, size_t size)
-{
-        int ret_ts = 0;
-        const char *p_each = buff;
-        int ret_ts_each; 
-        while (p_each < buff + size)
-        {
-                p_each = memchr(p_each, 0x47, size - (p_each - buff));
-                if (p_each == NULL)
-                {
-                        break;
-                }
-                else if (p_each +3 >= buff + size)
-                {
-                        break;
-                }
-                else
-                {
-                        ret_ts_each = is_mpeg_ts_each(p_each, size - (p_each - buff));
-                        if (ret_ts_each == 1)
-                        {
-                                ret_ts = 1;
-                                break;
-                        }
-                        p_each++;
-                }
-        }
-        return ret_ts;
-}
-
-
-void *memchr_flv(const char *buff, size_t size)
-{
-        void *ret_memflv = NULL;
-        const char *p = buff;
-        while (p < buff + size)
-        {
-                if (*p == 0x08 || *p == 0x09 || *p == 0x12)
-                {
-                        ret_memflv = (void *)p;
-                        break;
-                }
-                p++;
-        }
-        return ret_memflv;
-}
-
-int is_flv_each(const char* buff, size_t size)
-{
-        int ret_flv_each = 0;
-        const char *p = buff;
-        int fit_times = 1;
-        size_t left;
-        size_t right = 11 + htonl(*(size_t *)p) & 0x00ffffff;
-        p += (right + 4);
-
-        while (p < (buff + size))
-        {
-                left = htonl(*(size_t *)(p - 4));
-                if (right==left&&(*(p) == 0x08 || *(p) == 0x09 || *(p) == 0x12))
-                {
-                        fit_times++;
-                        if (fit_times > FIT_TIMES)
-                        {
-                                ret_flv_each = 1;
-                                break;
-                        }
-                }
-                else
-                {
-                        break;
-                }
-                if ((p + 3) >= (buff + size))
-                {
-                        break;
-                }
-                right = 11 + htonl(*(size_t *)p) & 0x00ffffff;
-                p += (right + 4);
-        }
-        return ret_flv_each;
-}
-
-int is_flv(const char* buff, size_t size)
-{
-        int ret_flv = 0;
-        int ret_flv_each;
-        const char *p_each = buff;
-
-        while (p_each < size + buff)
-        {
-                p_each = memchr_flv(p_each, size - (p_each - buff));
-                if (p_each == NULL)
-                {
-                        break;
-                }
-                else if (p_each + 3 >= buff + size)
-                {
-                        break;
-                }
-                else
-                {
-                        ret_flv_each = is_flv_each(p_each, size - (p_each - buff));
-                        if (ret_flv_each == 1)
-                        {
-                                ret_flv = 1;
-                                break;
-                        }
-                        p_each++;
-                }
-        }
-        return ret_flv;
-}
-
-
-
-int is_mp4_part_boxtype(const char *buff)
-{
-        int i;
-        size_t size_type_h;
-        for (i = 0; i < count_type; i++)
-        {
-                size_type_h = strlen(mp4_box_type_all[i]);
-                if (memcmp(buff, mp4_box_type_all[i], size_type_h) == 0)
-                        return 1;
-        }
-        return 0;
-}
-
-int char_is_mp4(char c)
-{
-        if (c >= 'a'&&c <= 'z' || c >= '0'&&c <= '9')
-        {
-                return 1;
-        }
-        else
-        {
-                return 0;
-        }
-}
-
-int is_mp4_part_4char(const char *buff)
-{
-        if (char_is_mp4(*buff) == 1 && char_is_mp4(*(buff + 1)) == 1 && char_is_mp4(*(buff + 2)) == 1 && char_is_mp4(*(buff + 3)) == 1)
-        {
-                return 1;
-        }
-        return 0;
-}
-
-void *memmem_mp4(const char *buff, size_t size)
-{
-        void *ret_memmp4 = NULL;
-        char s;
-        const char *p = buff;
-        while (p + 3 < buff + size)
-        {
-                if (is_mp4_part_4char(p) == 1)
-                {
-                        ret_memmp4 = (void *)p;
-                        break;
-                }
-                p++;
-        }
-        return ret_memmp4;
-}
-
-int is_mp4_each(const char* buff, size_t size)
-{
-        int ret_mp4_each = 0;
-        int ret_mp4_part_4char;
-        int sig_boxtype = 0;
-        if (is_mp4_part_boxtype(buff) == 1)
-        {
-                sig_boxtype = 1;
-        }
-        const char *p = buff;
-        int fit_times = 1;
-
-        size_t size_h;
-
-        p += 8;
-        while (p + 4 < (buff + size))
-        {
-                ret_mp4_part_4char = is_mp4_part_4char(p);
-                if (ret_mp4_part_4char == 1)
-                {
-                        fit_times++;
-                        if (is_mp4_part_boxtype(p) == 1)
-                        {
-                                sig_boxtype++;
-                        }
-                        if (fit_times > FIT_TIMES&&sig_boxtype >= 1)
-                        {
-                                ret_mp4_each = 1;
-                                break;
-                        }
-                        if (fit_times > FIT_TIMES+1)
-                        {
-                                break;
-                        }
-                }				
-
-                else
-                {
-                        p -= 8;
-                        size_h = htonl(*(size_t *)(p - 4));
-                        p += size_h;
-                        if (p + 4 < buff + size) 
-                        {
-                                ret_mp4_part_4char = is_mp4_part_4char(p);
-                                if (ret_mp4_part_4char == 1)
-                                {
-                                        fit_times++;
-                                        if (is_mp4_part_boxtype(p) == 1)
-                                        {
-                                                sig_boxtype++;
-                                        }
-                                        if (fit_times > FIT_TIMES&&sig_boxtype >= 1)
-                                        {
-                                                ret_mp4_each = 1;
-                                                break;
-                                        }
-                                        if (fit_times > FIT_TIMES + 1)
-                                        {
-                                                break;
-                                        }
-                                }
-                                else
-                                {
-                                        break;
-                                }
-                        }
-                }
-                p += 8;
-        }
-        return ret_mp4_each;
-}
-
-int is_mp4(const char* buff, size_t size)
-{
-        int ret_mp4 = 0;
-        int ret_mp4_each;
-        const char *p_each = buff;
-
-        while (p_each < buff + size)
-        {
-                p_each = (const char *)memmem_mp4(p_each, size - (p_each - buff));
-                if (p_each == NULL)
-                {
-                        break;
-                }
-                else if (p_each + 12 >= buff + size || p_each - 4 < buff)
-                {
-                        break;
-                }
-                else
-                {			
-                        ret_mp4_each = is_mp4_each(p_each, size - (p_each - buff));
-                        if (ret_mp4_each == 1)
-                        {
-                                ret_mp4 = 1;
-                                break;
-                        }
-                        p_each++;
-                }
-        }
-        return ret_mp4;
-}
-
-int AV_container_identify(const char* buff, size_t size)
-{
-        if (1 == is_mpeg_ts(buff, size))
-        {
-                return AV_CONTAINER_MPEGTS;
-        }
-        if (1 == is_flv(buff, size))
-        {
-                return AV_CONTAINER_FLV;
-        }
-        if (1 == is_mp4(buff, size))
-        {
-                return AV_CONTAINER_MP4;
-        }
-        return UNKNOWN;
-}
-
-
diff --git a/src/vdefine.o b/src/vdefine.o
deleted file mode 100644
index d6340f4..0000000
--- a/src/vdefine.o
+++ /dev/null
diff --git a/test/Makefile b/test/Makefile
index 862ea60..10cfc18 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -3,16 +3,16 @@ CFLAGS = -g
 LIB_PATH = ../lib
 INC_PATH = ../inc
 BIN_PATH = ../bin
-LIB = -lvdefine
+LIB = -lav_format_identify
 TARGET = test test_dir
 
-all::$(TARGET)
+all:$(TARGET)
 
 test:test.c
-	(rm -f $@; $(CC)  -o $@ -I$(INC_PATH) $^ -L$(LIB_PATH) $(LIB); cp $@ $(BIN_PATH);)
+	(rm -f $@; $(CC) -o $@ $(CFLAGS) -I$(INC_PATH) $^ -L$(LIB_PATH) $(LIB); cp -f $@ $(BIN_PATH);)
 
 test_dir:test_dir.c
-	(rm -f $@; $(CC)  -o $@ -I$(INC_PATH) $^ -L$(LIB_PATH) $(LIB); cp $@ $(BIN_PATH);)
+	(rm -f $@; $(CC) -o $@ $(CFLAGS) -I$(INC_PATH) $^ -L$(LIB_PATH) $(LIB); cp -f $@ $(BIN_PATH);)
 
 clean:
 	rm -f $(TARGET)
diff --git a/test/test b/test/test
index 09ea650..801cec6 100644
--- a/test/test
+++ b/test/test
diff --git a/test/test.c b/test/test.c
index baedfb1..935e565 100644
--- a/test/test.c
+++ b/test/test.c
@@ -1,8 +1,10 @@
-#include "vdefine.h"
-#define SIZE_BUFF 0xffffffff-1
+#include "av_format_identify.h"
+#define SIZE_BUFF 0xfffffffff//0xffffffffffffffff
 #include <dirent.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <stdint.h>
+
 typedef struct buff_inf_h
 {
         char *buff;
@@ -13,7 +15,7 @@ buff_inf *buff_get(char *vfile) {
         buff_inf *buff_inf_h = (buff_inf *)malloc(sizeof(buff_inf));
 
         FILE *fr = NULL;
-        char *buff_ori = (char *)malloc(sizeof(char *)*SIZE_BUFF);
+        char *buff_ori = (char *)malloc(sizeof(char)*SIZE_BUFF);
         char *buff = buff_ori;
         memset(buff, 0, sizeof(buff));
         if ((fr = fopen(vfile, "rb")) == NULL)
diff --git a/test/test_dir b/test/test_dir
index c31057d..ef2c7d5 100644
--- a/test/test_dir
+++ b/test/test_dir
diff --git a/test/test_dir.c b/test/test_dir.c
index d100872..ff28e49 100644
--- a/test/test_dir.c
+++ b/test/test_dir.c
@@ -1,8 +1,9 @@
-#include "vdefine.h"
-#define SIZE_BUFF 0xffffffff-1
+#include "av_format_identify.h"
+#define SIZE_BUFF 0xfffffffff//0xffffffffffffffff
 #include <dirent.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <stdint.h>
 #define SIZE_FILE 50
 typedef struct buff_inf_h
 {
@@ -14,7 +15,7 @@ buff_inf *buff_get(char *vfile) {
         buff_inf *buff_inf_h = (buff_inf *)malloc(sizeof(buff_inf));
 
         FILE *fr = NULL;
-        char *buff_ori = (char *)malloc(sizeof(char *)*SIZE_BUFF);
+        char *buff_ori = (char *)malloc(sizeof(char)*SIZE_BUFF);
         char *buff = buff_ori;
         memset(buff, 0, sizeof(buff));
         if ((fr = fopen(vfile, "rb")) == NULL)