new ed1

4 files changed, 784 insertions, 0 deletions

diff --git a/src/vdefine.c b/src/vdefine.c
new file mode 100644
index 0000000..a0395fe
--- /dev/null
+++ b/src/vdefine.c
@@ -0,0 +1,465 @@
+#include "vdefine.h"
+
+#define AV_CONTAINER_MPEGTS	1
+#define AV_CONTAINER_FLV	2
+#define AV_CONTAINER_MP4	3
+#define UNKNOWN 4
+#define FIT_TIMES 2
+#define MAX_FLV_FRAME max_flv_frame;//?
+/*int xtoint(const char* buff, size_t size)
+{
+	int size_h = 0;
+	int i;
+    unsigned char *add=(unsigned char *)malloc(sizeof(unsigned char *));
+	for (i = 0; i < size; i++)
+	{
+        memcpy(add,(buff+i),1);
+		size_h +=((*add) << (8 * (size - i - 1)));
+	}
+    free(add);
+	add = NULL;
+    return size_h;
+
+}*/
+int is_mpeg_ts_each(const char *buff_each, size_t size_each, const char *buff, size_t size)
+{
+	int ret_ts_each = 0;
+	const char *p = buff_each;
+	int fit_times = 1;// 0;//special 1;//CH--0;
+	p += 188;
+
+    //if ((buff_each+3)>=(buff_each+size_each))
+    //    return 0;
+    //int cont_cout_ori = xtoint(buff_each + 3, 1);
+    //cont_cout_ori = cont_cout_ori % 16;
+	size_t cont_cout_ori, cont_cout_end, cont_cout_pre, cont_cout_aft;
+	cont_cout_ori = htonl(*(size_t *)buff_each) & 0x0000000f;
+	cont_cout_pre = cont_cout_ori;
+	//size_t cont_cout_aft;//int cont_cout_aft;
+	while (p < (buff_each + size_each))//=?
+	{
+		if (*p == 0x47)
+		{
+			if ((p + 3) < (buff_each + size_each))
+            {
+                //cont_cout_aft = xtoint(p + 3, 1);
+                //cont_cout_aft = cont_cout_aft % 16;
+                cont_cout_aft = htonl(*(size_t *)p) & 0x0000000f;
+				//cont_cout_aft = (cont_cout_aft == 0 ? 16 : cont_cout_aft);
+				if (cont_cout_aft == (cont_cout_pre + 1) % 16)
+				{
+					fit_times++;
+				}
+				else
+				{
+					break;
+					//return 0;
+				}
+            }
+			if (fit_times > FIT_TIMES)
+			{
+				size_t whole_pack_cout = size_each / 188;
+				if (size_each % 188 == 0)
+				{
+					whole_pack_cout--;
+				}
+				size_t whole_pack_bites = whole_pack_cout * 188;
+				const char *pack_tail = buff_each + whole_pack_bites;
+				if (*pack_tail == 0x47)
+				{
+					//if (pack_tail + 3 < buff_each + size_each)
+					//{
+					//	cont_cout_end = htonl(*(size_t *)pack_tail) & 0x0000000f;
+					//	if (cont_cout_end != (cont_cout_ori + whole_pack_cout) % 16)
+					//	{
+					//		//ret_ts_each = 0;
+					//		break;
+					//	}
+					//}
+					ret_ts_each = 1;
+					break;
+				}
+				break;
+				//ret_ts_each = 1;
+				//break;
+				//return 1;
+			}
+        }
+		else
+		{
+			break;
+			//return 0;
+		}
+		
+		cont_cout_pre = cont_cout_aft;//cont_cout_ori = cont_cout_aft;
+        p += 188;
+	}
+	return ret_ts_each;//return 0;
+}
+
+int is_mpeg_ts(const char* buff, size_t size)
+{
+	int ret_ts = 0;
+	//const char*p = buff;
+	const char *p_each = buff;
+	//size_t size_move = 0;
+    int ret_ts_each; 
+	while (p_each < buff + size)//while (size_move < size)//while (size_move <= 188)
+	{
+		p_each = memchr(p_each, 0x47, size - (p_each - buff));
+		if (p_each == NULL)
+		{
+			//return 0;
+			break;
+		}
+		else if (p_each +3 >= buff + size)//else if (p_each + 3 >= buff + size || p_each - buff > 187)
+		{
+			break;
+		}
+		else
+		{
+			ret_ts_each = is_mpeg_ts_each(p_each, size - (p_each - buff), buff, size);//int ret = is_mpeg_ts_each(p_each,size-(p_each-buff));
+            if (ret_ts_each == 1)
+			{
+                //printf("p_each... is %x,%x,%x,%x,%x,%x.\n",*p_each,*(p_each+1),*(p_each+2),*(p_each+3),*(p_each+4),*(p_each+5));
+				//return 1;
+				ret_ts = 1;
+				break;
+			}
+			p_each++;
+			//size_move = p_each - buff;//size_move+= (p_each - buff);
+		}
+	}
+	return ret_ts;
+}
+/*void *memchr_flv(const char *buff, size_t size, int count_type)//void * memchr_flv(const void * buff, size_t size, int count_type)
+{
+    int sig;
+    int i;
+	while (size)
+	{
+		sig = 0;//int sig = 0;
+		i = 0;//int i;
+		for (i = 0; i < count_type; i++)
+		{
+				if (*buff != (const char)flv_tag_type_all[i])//if (*(unsigned char *)buff != (unsigned char)flv_tag_type_all[i]);//?
+				    sig++;
+		}
+		if (sig == count_type)
+		{
+			buff ++;//buff = (unsigned char *)buff + 1;
+			size --;
+		}
+		else
+			return (void *)buff;
+	}
+	return NULL;
+}*/
+
+void *memchr_flv(const char *buff_each, size_t size_each)
+{
+	void *ret_memflv = NULL;
+	//int i;
+	const char *p = buff_each;
+	while (p < buff_each + size_each)//for (i = 0; i < size_ each; i++)
+	{
+		if (*p == 0x08 || *p == 0x09 || *p == 0x12)
+		{
+			ret_memflv = (void *)p;
+			break;
+		}
+		p++;
+	}
+	return ret_memflv;
+}
+
+int is_flv_each(const char* buff_each, size_t size_each)
+{
+	int ret_flv_each = 0;
+	const char *p = buff_each;
+	int fit_times = 1;//CH--0;
+    //int left_ori;
+    //unsigned int left;
+	size_t left;//unsigned int left;
+    //if ((p+3)>=(buff_each+size_each))
+    //    return 0;
+	size_t right = 11 + htonl(*(size_t *)p) & 0x00ffffff;//int right = 11 + xtoint(p + 1, 3);
+    p += (right + 4);
+
+	while (p < (buff_each + size_each))
+	{
+		//left_ori = xtoint(p - 4, 4);
+        //left = left_ori;
+		left = htonl(*(size_t *)(p - 4));// left = xtoint(p - 4, 4);
+        if (right==left&&(*(p) == 0x08 || *(p) == 0x09 || *(p) == 0x12))
+		{
+			fit_times++;
+			if (fit_times > FIT_TIMES)
+			{
+				ret_flv_each = 1;
+				break;
+				//return 1;
+			}
+		}
+		else
+		{
+			break;
+			//return 0;
+		}
+		if ((p + 3) >= (buff_each + size_each))
+		{
+			break;
+			//return 0;
+		}
+		right = 11 + htonl(*(size_t *)p) & 0x00ffffff;//right = 11 + xtoint(p + 1, 3);
+		p += (right + 4);
+	}
+	return ret_flv_each;//return 0;
+}
+
+int is_flv(const char* buff, size_t size)
+{
+	int ret_flv = 0;
+	int ret_flv_each;
+	const char*p = buff;
+	const char *p_each = buff;
+	//size_t size_move = 0;
+
+	while (p_each < size + buff)//while (size_move < size)
+	{
+		//int flv_sig[3]={ 0x08, 0x09, 0x12 };
+		p_each = memchr_flv(p_each, size - (p_each - buff));// size_move, 3);
+		if (p_each == NULL)
+		{
+			break;
+			//return 0;
+		}
+		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;
+				//return 1;
+			}
+			p_each++;///
+			//size_move = p_each - buff;//size_move += (p_each - buff);
+		}
+	}
+	return ret_flv;//return 0;
+}
+
+
+/*void * memmem_mp4(const char * buf, size_t size)//, int count_type)
+{
+	int i;
+	const char *ret;
+    const char *ret_rec;//??
+    for (i = 0; i < count_type; i++)
+    {
+        ret = (const char *)memmem(buf,size, mp4_box_type_all[i], strlen(mp4_box_type_all[i]));
+        if (ret != NULL)
+            break;
+    }
+    if (ret == NULL)
+        return NULL;
+	for (i = 0; i < count_type; i++)
+	{
+        ret_rec = ret;//memcpy(ret_rec, ret, strlen(ret));
+        ret = (const char *)memmem(buf,size, mp4_box_type_all[i], strlen(mp4_box_type_all[i]));
+        if (ret != NULL)
+        {
+            if (ret_rec > ret)
+                return (void *)ret;
+            else if (ret_rec < ret)
+                return (void *)ret_rec;
+            else
+                continue;
+        }
+        else
+            ret = ret_rec;
+    }
+	return (void *)ret;//return NULL;
+}*/
+
+int is_mp4_part_spe(const char *buff)//, int count_type)
+{
+	int i;
+	//const char *ret;
+	size_t size_type_h;
+	for (i = 0; i < count_type; i++)
+	{
+		size_type_h = strlen(mp4_box_type_all[i]);
+		//ret = (const char *)memmem(buff, size_type_h, mp4_box_type_all[i], size_type_h);
+		//if (ret != NULL)
+		//	return 1;
+		if (memcmp(buff, mp4_box_type_all[i], size_type_h) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+int c_is_mp3(char c)
+{
+	if (c >= 'a'&&c <= 'z' || c >= '0'&&c <= '9')
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+int is_mp4_part(const char *buff_part)
+{
+	if (c_is_mp3(*buff_part) == 1 && c_is_mp3(*(buff_part + 1)) == 1 && c_is_mp3(*(buff_part + 2)) == 1 && c_is_mp3(*(buff_part + 3)) == 1)
+	{
+		//ret_memmp4 = (void *)p;
+		return 1;
+	}
+	return 0;
+}
+
+void *memmem_mp4(const char *buff_each, size_t size_each)
+{
+	void *ret_memmp4 = NULL;
+	char s;
+	const char *p = buff_each;
+	//int i;
+	while (p + 3 < buff_each + size_each)//for (i = 0; i < size; i++)
+	{
+		if (is_mp4_part(p) == 1 && is_mp4_part_spe(p) == 1)
+		{
+			ret_memmp4 = (void *)p;
+			break;
+		}
+		p++;
+	}
+	return ret_memmp4;
+}
+
+int is_mp4_each(const char* buff_each, size_t size_each, const char *buff)//, int count_type)
+{
+	int ret_mp4_each = 0;
+	int ret_mp4_part;
+	int sig_spe = 0;
+
+	const char *p = buff_each;
+	int fit_times = 1;//CH--0;
+	
+	//int size_h_ori;
+	//unsigned int size_h;
+	size_t size_h;//unsigned int size_h;
+    
+	p += 8;
+	while (p + 4 < (buff_each + size_each))
+	{
+		ret_mp4_part = is_mp4_part(p);// , count_type);
+		if (ret_mp4_part == 1)
+		{
+			fit_times++;
+			if (is_mp4_part_spe(p) == 1)
+			{
+				sig_spe++;
+			}
+			if (fit_times > FIT_TIMES&&sig_spe >= 1)
+			{
+				ret_mp4_each = 1;
+				break;
+				//return 1;
+			}
+		}				
+			
+		else
+		{
+			p -= 8;
+			//size_h_ori = xtoint(p - 8 - 4, 4);
+			//size_h = size_h_ori;
+			size_h = htonl(*(size_t *)(p - 4));//size_h = xtoint(p - 8 - 4, 4);
+			p += size_h;//p += (size_h - 8);
+			if (p + 4 < buff_each + size_each) 
+			{
+				ret_mp4_part = is_mp4_part(p);// , count_type);
+				if (ret_mp4_part == 1)
+				{
+					fit_times++;
+					if (is_mp4_part_spe(p) == 1)
+					{
+						sig_spe++;
+					}
+					if (fit_times > FIT_TIMES&&sig_spe >= 1)
+					{
+						ret_mp4_each = 1;
+						break;
+						//return 1;
+					}
+				}
+			}
+		}
+		p += 8;
+	}
+	return ret_mp4_each;//return 0;
+}
+
+int is_mp4(const char* buff, size_t size)
+{
+	int ret_mp4 = 0;
+	int ret_mp4_each;
+	const char *p = buff;
+	const char *p_each = buff;
+	//size_t size_move = 0;
+
+	//int count_type = sizeof(mp4_box_type_all) / sizeof(char *);
+    //int ret;
+	while (p_each < buff + size)//while (size_move < size)
+	{
+		p_each = (const char *)memmem_mp4(p_each, size - (p_each - buff));//size_move, count_type);
+		if (p_each == NULL)
+		{
+			break;
+			//return 0;
+		}
+		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), buff);//,count_type);//int ret = is_mp4_each(p_each, size - (p_each - buff), buff,count_type);
+			if (ret_mp4_each == 1)
+			{
+				ret_mp4 = 1;
+				break;
+				//return 1;
+			}
+			p_each++;
+			//size_move = p_each - buff;//size_move += (p_each - buff);
+		}
+	}
+	return ret_mp4;//return 0;
+}
+
+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.h b/src/vdefine.h
new file mode 100644
index 0000000..8ad8c50
--- /dev/null
+++ b/src/vdefine.h
@@ -0,0 +1,50 @@
+#ifndef _VDEFINE_H
+#define _VDEFINE_H
+
+#include <arpa/inet.h>
+#include <stdlib.h>
+#define _GNU_SOURCE
+#define __USE_GNU
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <sys/types.h>  
+
+#include <sys/io.h>
+
+#include <arpa/inet.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" };
+//const int flv_tag_type_all[] = { 0x08,0x09,0x12 };
+int count_type = sizeof(mp4_box_type_all) / sizeof(char *);
+
+/*int xtoint(const char* buff, size_t size);
+int is_mpeg_ts_each(const char *buff, size_t size);
+int is_mpeg_ts(const char* buff, size_t size);
+void * my_memchr_flv(const char * buffer, size_t size, int count_set);//void * my_memchr_flv(const void * buffer, size_t size, int count_set);
+int is_flv_each(const char* buff, size_t size);
+int is_flv(const char* buff, size_t size);
+void * my_memmem_mp4(const char * buf, size_t size, int count_type);
+int is_mp4_each_part(const char *buff, int count_type);
+int is_mp4_each(const char* buff, size_t size, const char *buff_s, int count_type);
+int is_mp4(const char* buff, size_t size);
+int AV_container_identify(const char* buff, size_t size);*/
+int is_mpeg_ts_each(const char *buff_each, size_t size_each, const char *buff, size_t size);
+int is_mpeg_ts(const char* buff, size_t size);
+void *memchr_flv(const char *buff_each, size_t size_each);
+int is_flv_each(const char* buff_each, size_t size_each);
+int is_flv(const char* buff, size_t size);
+int is_mp4_part_spe(const char *buff);//, int count_type)
+int c_is_mp3(char c);
+int is_mp4_part(const char *buff_part);
+void *memmem_mp4(const char *buff_each, size_t size_each);
+int is_mp4_each(const char* buff_each, size_t size_each, const char *buff);//, int count_type)
+int is_mp4(const char* buff, size_t size);
+int AV_container_identify(const char* buff, size_t size);
+
+
+#endif
diff --git a/test/test.c b/test/test.c
new file mode 100644
index 0000000..6dbc11e
--- /dev/null
+++ b/test/test.c
@@ -0,0 +1,124 @@
+#include "vdefine.h"
+#define SIZE_BUFF 16*16*16*16*16*16*16*16-1//6*16*16*16*16*16
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+typedef struct buff_inf_h
+{
+	char *buff;
+	size_t size;
+}buff_inf;
+
+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);//CH
+	char *buff = buff_ori;//CH
+    memset(buff, 0, sizeof(buff));
+	if ((fr = fopen(vfile, "rb")) == NULL)
+	{
+		perror("fopen error:");
+		buff_inf_h->buff = NULL;
+		buff_inf_h->size = 0;
+		return buff_inf_h;//-1;
+	}
+	size_t i = 0;//unsigned int i = 0;//size_t i = 0;
+	//int j = 0;
+	while (!feof(fr))
+	{
+		fread(buff, 1, 1, fr);
+		buff += 1;
+		i++;
+	}
+	buff_inf_h->buff = (char *)malloc(sizeof(char *) * (i-1));//(i-2));
+    memcpy(buff_inf_h->buff, buff - i, i-1);//i-2);
+    buff_inf_h->size = i-1;//i - 2;
+    //buff_inf_h.buff = buff - i;
+	//buff_inf_h.size = i;
+	free(buff_ori);//CH--free(buff - i);//?
+    buff_ori = NULL;
+    fclose(fr);
+	return buff_inf_h;
+
+}
+int main(int argc, char *argv[])
+{
+    char *vfile = argv[1];    
+    buff_inf *buff_inf_h;
+    //CH--char *buff;// = (char *)malloc(sizeof(char *)*size);//;
+    int ret;
+    int ret_sig = atoi(argv[2]);
+    int sig_show_all = atoi(argv[3]);
+    int sig_choose_all = atoi(argv[4]);
+    size_t size;
+    
+    buff_inf_h = buff_get(vfile);
+    if (buff_inf_h->size == 0)
+    {
+            printf("read file failed.\n");
+            return -1;
+    }
+    if (sig_choose_all == 0)
+    {
+            int divide_h = 10;
+            int divide_s = 0;
+            int divide_e = 1;
+
+            size = (buff_inf_h->size / divide_h)*(divide_e - divide_s);
+
+            //CH--buff = (char *)malloc(sizeof(char *)*size);
+            //CH--memcpy(buff, buff_inf_h->buff + (buff_inf_h->size / divide_h)*divide_s, size);
+
+            //printf("buff_whole is               %p.\n", buff_inf_h->buff);
+            //printf("buff_inf_h.size/divide_h is %x.\n", buff_inf_h->size / divide_h);
+            //printf("buff starts from(>=)        %p.\n", buff);
+            //printf("buff ends at(<)             %p.\n", buff + size - 1);//+size
+            ret = AV_container_identify(buff_inf_h->buff + (buff_inf_h->size / divide_h)*divide_s, size);;//CCH--ret = AV_container_identify(buff, size);//CH--(const char *)?
+            //CH--free(buff);
+            //CH--buff = NULL;
+            //printf("define : %d.\n", ret);
+            //printf("size of whole buff is  %d.\n", buff_inf_h->size);//size - 1
+            //printf("size of chosen buff is %d.\n", size);
+    }
+    else
+            ret = AV_container_identify(buff_inf_h->buff, buff_inf_h->size);
+    if (sig_show_all == 0)
+    {
+            if (ret != ret_sig)
+            {
+                    printf("-----------------data of [%s] is kind of [%d].\n",vfile,ret);// dp->d_name, ret);
+                    //printf("define : %d.\n", ret);
+                    printf("size of whole buff is %d.\n", buff_inf_h->size);
+                    if  (sig_choose_all == 0)
+                            printf("size of chosen buff is %d.\n", size);
+
+            }
+    }
+    else
+    {
+            printf("-----------------data of [%s] is kind of [%d].\n", vfile, ret);// dp->d_name, ret);
+            printf("size of whole buff is %d.\n", buff_inf_h->size);
+            if  (sig_choose_all == 0)
+                    printf("size of chosen buff is %d.\n", size);
+    }
+    free(buff_inf_h->buff);//CH--
+    buff_inf_h->buff = NULL;//CH--
+    free(buff_inf_h);//CH--
+    buff_inf_h = NULL;//CH--
+    /*
+    free(buff);
+
+    free(buff_inf_h->buff);
+    buff_inf_h = NULL;
+    free(buff_inf_h);
+    return ret;
+    */
+   
+    //CH--free(buff_inf_h->buff);
+    //CH--buff_inf_h = NULL;
+    //CH--free(buff_inf_h);
+
+    
+    return ret;
+}
diff --git a/test/test_dir.c b/test/test_dir.c
new file mode 100644
index 0000000..44a7afd
--- /dev/null
+++ b/test/test_dir.c
@@ -0,0 +1,145 @@
+#include "vdefine.h"
+#define SIZE_BUFF 16*16*16*16*16*16*16*16-1//6*16*16*16*16*16
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#define SIZE_FILE 50
+typedef struct buff_inf_h
+{
+	char *buff;
+	size_t size;
+}buff_inf;
+
+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);//CH
+	char *buff = buff_ori;//CH
+    memset(buff, 0, sizeof(buff));
+	if ((fr = fopen(vfile, "rb")) == NULL)
+	{
+		perror("fopen error:");
+		buff_inf_h->buff = NULL;
+		buff_inf_h->size = 0;
+		return buff_inf_h;//-1;
+	}
+	size_t i = 0;//unsigned int i = 0;//size_t i = 0;
+	//int j = 0;
+	while (!feof(fr))
+	{
+		fread(buff, 1, 1, fr);
+		buff += 1;
+		i++;
+	}
+	buff_inf_h->buff = (char *)malloc(sizeof(char *) * (i-1));//(i-2));
+    memcpy(buff_inf_h->buff, buff - i, i-1);//i-2);
+    buff_inf_h->size = i-1;//i - 2;
+    //buff_inf_h.buff = buff - i;
+	//buff_inf_h.size = i;
+	free(buff_ori);//CH--free(buff - i);//?
+    buff_ori = NULL;
+    fclose(fr);
+	return buff_inf_h;
+
+}
+int main(int argc, char *argv[])
+{
+    DIR *dirp;
+    struct dirent *dp;
+    char *vdir = argv[1];
+    char *vfile_ori = (char *)malloc(SIZE_FILE);
+    memcpy(vfile_ori,vdir,strlen(vdir));
+    strcat(vfile_ori, "/");
+    char *vfile = (char *)malloc(SIZE_FILE);
+    //strcat(vdir,".dir");
+    dirp = opendir(vdir);
+    struct stat info;
+    
+    buff_inf *buff_inf_h;
+    //CH--char *buff;// = (char *)malloc(sizeof(char *)*size);//;
+    int ret;
+    int ret_sig = atoi(argv[2]);
+    int sig_show_all = atoi(argv[3]);
+    int sig_choose_all = atoi(argv[4]);
+    size_t size;
+    while ((dp = readdir(dirp)) != NULL) 
+    {
+            memcpy(vfile,vfile_ori,SIZE_FILE);
+            strncat(vfile, dp->d_name, strlen(dp->d_name));//strcat(vfile,dp->d_name);//vfile = dp->d_name;//fileinfo->name;//&((fileinfo->name)[0]);//argv[1];// "0003.dat";
+            
+            stat(vfile, &info);
+            if(S_ISDIR(info.st_mode))
+                continue;
+            buff_inf_h = buff_get(vfile);
+            if (buff_inf_h->size == 0)
+            {
+                    printf("read file failed of %s.\n",vfile);
+                    return -1;
+            }
+            if (sig_choose_all == 0)
+            {
+                    int divide_h = 10;
+                    int divide_s = 0;
+                    int divide_e = 1;
+
+                    size = (buff_inf_h->size / divide_h)*(divide_e - divide_s);
+
+                    //CH--buff = (char *)malloc(sizeof(char *)*size);
+                    //CH--memcpy(buff, buff_inf_h->buff + (buff_inf_h->size / divide_h)*divide_s, size);
+
+                    //printf("buff_whole is               %p.\n", buff_inf_h->buff);
+                    //printf("buff_inf_h.size/divide_h is %x.\n", buff_inf_h->size / divide_h);
+                    //printf("buff starts from(>=)        %p.\n", buff);
+                    //printf("buff ends at(<)             %p.\n", buff + size - 1);//+size
+                    ret = AV_container_identify(buff_inf_h->buff + (buff_inf_h->size / divide_h)*divide_s, size);;//CCH--ret = AV_container_identify(buff, size);//CH--(const char *)?
+                    //CH--free(buff);
+                    //CH--buff = NULL;
+                    //printf("define : %d.\n", ret);
+                    //printf("size of whole buff is  %d.\n", buff_inf_h->size);//size - 1
+                    //printf("size of chosen buff is %d.\n", size);
+            }
+            else
+                    ret = AV_container_identify(buff_inf_h->buff, buff_inf_h->size);
+            if (sig_show_all == 0)
+            {
+                    if (ret != ret_sig)
+                    {
+                            printf("-----------------data of [%s] is kind of [%d].\n", dp->d_name, ret);
+                            //printf("define : %d.\n", ret);
+                            printf("size of whole buff is %d.\n", buff_inf_h->size);
+                            if  (sig_choose_all == 0)
+                                printf("size of chosen buff is %d.\n", size);
+
+                    }
+            }
+            else
+            {
+                    printf("-----------------data of [%s] is kind of [%d].\n", dp->d_name, ret);
+                    printf("size of whole buff is %d.\n", buff_inf_h->size);
+                    if  (sig_choose_all == 0)
+                            printf("size of chosen buff is %d.\n", size);
+            }
+            free(buff_inf_h->buff);//CH--
+            buff_inf_h->buff = NULL;//CH--
+            free(buff_inf_h);//CH--
+            buff_inf_h = NULL;//CH--
+    }
+    /*
+    free(buff);
+
+    free(buff_inf_h->buff);
+    buff_inf_h = NULL;
+    free(buff_inf_h);
+    return ret;
+    */
+   
+    //CH--free(buff_inf_h->buff);
+    //CH--buff_inf_h = NULL;
+    //CH--free(buff_inf_h);
+
+    free(vfile);
+    free(vfile_ori);
+    
+    return ret;
+}