精华内容
下载资源
问答
  • 压缩原理及步骤&&压缩比的计算压缩原理及步骤压缩第一步: 将一个文件以各个字符出现次数为权值建立哈夫曼树,这样每个字符可以用从树根到该字符所在到叶子节点路径来表示。(左为0,右为1) 压缩第二步: ...

    压缩原理及步骤&&压缩比的计算

    压缩原理及步骤

    压缩的第一步:

    将一个文件以各个字符出现的次数为权值建立哈夫曼树,这样每个字符可以用从树根到该字符所在到叶子节点的路径来表示。(左为0,右为1)

    压缩第二步:

    哈夫曼编码有一个很重要的特性:每个字符编码不会成为另一个编码的前缀。这个特性保证了即使我们把不同长度的编码存在一起,仍然也可以把它们分离开,不会出现认错人的冲突。
    那么我们就可以把所有的字符按照原有顺序用其编码替换,构建新的字符串作为其压缩后的串。

    压缩第三步:

    有的小伙伴可能要问了,这样一搞不是越变越多了么,哪是什么压缩。哈哈,大部分孩子可能已经想到啦,既然单位编码除了0就是1为什么还要用字节来存呢,用位来保存,8个单位编码为1位。这样转化完成后的串才是真正压缩后的串。

    当然,因为我们还要进行解压,所以这里构建的树也要和串一并加入到文件。

    压缩比的计算

    介绍完步骤,我们来计算一下哈夫曼编码的压缩比。
    用len表示串长度,path(i)表示每i个字符的编码长度,那么根据上文所介绍的原理,我们可以很容易知道,串通过哈夫曼压缩后的长度为
    sum(path(i)) 1<=i<=len
    这个式子虽然正确但不能直观的感受的压缩比,所以我们来假设一种平均情况进行估算
    假如一个串长度为n,一共包含m个不同的字符,那么所构建成的哈夫曼树的总结点数为 2*m-1
    假设,n很大,那么可以忽略树的保存所占用的空间。如果假设此串中每个字符出现的次数都是相同的,那么也可以假设,它们所生成的哈夫曼树是完全二叉树.
    即每个叶子(字符)的深度为log(m)+1,则路径长度为log(m)。log(m)即为该串字符的平均路径长度,那么压缩后的串长为log(m)/8。
    由上可以得出平均压缩比的公式为:
    n*log(2*m-1)/8/n = log(2*m-1)/8;
    可见压缩比的大小主要与m有关,即不同的字符越少越好。
    ascii码的范围为0~255,共有256种不同字符,代入上式得
    log(2*256-1) = 6.23 …
    向上取整为7(路径个数哪有小数)
    7/8 = 0.875 = %87.5
    所以哈夫曼编码的平均压缩比为%87.5。

    强调

    上述的假设在计算情况中忽略了对哈夫曼树的保存,所以只在文件总长度与不同字符总数相差很大时才生效。

    考虑ascii码外的其它语言

    一开始为考虑这个钻了牛角尖,想着去统一用wchar_t保存或是转为Unicode等等什么的。但其实不必那么复杂,因为汉字(不仅仅汉字,任何字符都是这样的)都是以字节为单位的,由多个字节组成的,将其分开对待,因为最终解压时恢复原串还是按照原有顺序组装,所以和纯英文文件的实现没有什么区别);

    需要注意的地方

    所有字符路径的总长不一定整除8,所以在按为保存时,要注意最后一项不足8的情况,进行补零,且要将补零的个数保存起来。

    代码对不同类型文档的压缩比测试情况

    英语文章

    样例文档:西游记英文节选

    原大小:7720
    压缩后:10476
    压缩比:1.356 – %135
    此处的文件压缩后不降反增,因为文件本身大小与不同字符的数量相差并不大,加上对树的保存后,空间大于压缩前。

    纯汉语文档

    样例文档:西游记
    原大小:1921978
    压缩后:1781234
    压缩比:0.926 – %92
    不同汉字的数量多。

    程序代码

    样例文档:github网页源代码
    原大小:46500
    压缩后:35116
    压缩比:0.755 – %76
    源代码中全是英文字母与符号,不超过100种,总大小与其相差近500倍,且代码重复词比较多。

    英语单词文档

    样例文档:英语单词5000
    原大小:20813
    压缩后:13523
    压缩比:0.649 – %65

    测试情况

    源代码

    压缩程序源文件 compress.cpp

    #include <iostream>
    #include <locale>
    #include <cstdlib>
    #include <fstream>
    #include <vector>
    #include <queue>
    
    using namespace std;
    
    const long long MAX_SIZE = 10000000000;//
    const int MAX_TYPE = 300;
    unsigned int *f = new unsigned int[MAX_TYPE];//计数
    unsigned int *p = new unsigned int[MAX_TYPE];//计下标
    char *v = new char[MAX_TYPE];
    char filename[20];
    char *s[MAX_TYPE];
    
    struct Node
    {
        unsigned int weight, parent, lson, rson;
        Node(){};
    }HuffmanTree[MAX_TYPE<<1];
    
    struct NodeCmp
    {
        bool operator()(int a, int b)
        {
            return HuffmanTree[a].weight > HuffmanTree[b].weight;
        }
    };
    
    int CreatTree(char *str, long long len)
    {
        int num = 1;
        for(int i=0;i<len;i++)
            f[str[i]]++;
        cout<<"len::"<<len<<endl;
        for(int i=0;i<len;i++)
        {
            if(f[str[i]])
            {
                HuffmanTree[num].weight = f[str[i]];
                HuffmanTree[num].lson = 0;
                HuffmanTree[num].rson = 0;
                f[str[i]] = 0;
                if(p[str[i]] == 0)
                    p[str[i]] = num;
                v[num] = str[i];
                ++num;
            }
        }
        cout<<"num::"<<num<<endl;
        return num;
    }
    
    void CodingTree(int num)
    {
        priority_queue<int, vector<int>, NodeCmp> q;
        for(int i=1;i<num;i++)
            q.push(i);
        int len = num;
        for(int i=0;i<num-2;i++)
        {
            int x = q.top(); q.pop();
            int y = q.top(); q.pop();
            HuffmanTree[len].weight = HuffmanTree[x].weight + HuffmanTree[y].weight;
            HuffmanTree[x].parent = HuffmanTree[y].parent = len;
            HuffmanTree[len].lson = y;
            HuffmanTree[len].rson = x;
            q.push(len++);
        }
    }
    
    void FindPath(int num)
    {
        char *t = new char[num];
        t[num-1] = '\0';
        for(int i=1;i<num;i++)
        {
            int son = i, father = HuffmanTree[i].parent;
            int start = num-1;
    
            while(father != 0)
            {
                --start;
                if(HuffmanTree[father].rson == son)
                    t[start] = '1';
                else
                    t[start] = '0';
                son = father;
                father = HuffmanTree[father].parent;
            }
            s[i] = new char[num - start];
            strcpy(s[i], &t[start]);
        }
    }
    
    void print(int num, long long len, char *str)
    {
        ofstream fout(filename, ios::out);
        fout<<num<<endl;
        for(int i=1;i<num;i++)
        {
            fout<<s[i]<<endl;
            fout<<v[i]<<endl;
        }
        long long pos = 0;
        char *ans = new char[MAX_SIZE];
    
        int now = 7;
        for(long long i=0;i<len;i++)
        {
            int k = 0;
            while(s[p[str[i]]][k] != '\0')
            {
                ans[pos] |= (s[p[str[i]]][k]-'0')<<now--;
                if(now < 0)
                {
                    now = 7;
                    pos++;
                }
                ++k;
            }
        }
    
        int zero = 0;
        if(now != 7) zero = now%7+1, pos++;
    
        fout<<zero<<" "<<pos<<endl;
        fout.write(ans, sizeof(char)*pos);
        fout.close();
    
        cout<<"zero::"<<zero<<endl;
    }
    
    int main(int argc, char **argv)
    {
        sprintf(filename, "%s.temp", argv[1]);
        ifstream fin(argv[1],ios::ate | ios::in);
        if(!fin)
        {
            cout<<"File open error!"<<endl;
            return 0;
        }
    
        long long size = fin.tellg();
        if(size > MAX_SIZE)
        {
            cout<<"Too long!"<<endl;
            return 0;
        }
        fin.seekg(0, ios::beg);
    
        char *str = new char[size+1];
        fin.read(str,size);
        fin.close();
    
    
        int num = CreatTree(str, size);
        CodingTree(num);
        FindPath(num);
        print(num, size, str);
    
        return 0;
    }

    解压程序源文件 compress.cpp

    #include <iostream>
    #include <locale>
    #include <cstdlib>
    #include <fstream>
    #include <vector>
    #include <queue>
    
    using namespace std;
    char filename[20];
    const long long MAX_SIZE = 10000000000;//
    const int MAX_TYPE = 300;
    struct Node
    {
        char v;
        int parent, lson, rson;
        Node(){};
    }HuffmanTree[MAX_TYPE<<1];
    
    char *str = new char[MAX_SIZE];
    char *ans = new char[MAX_SIZE];
    
    void CreatTree(char *t, char v, int &pos)
    {
        int root = 0;
        for(int i=0;t[i]!='\0';i++)
        {
            if(t[i] == '1')
            {
                if(HuffmanTree[root].rson == 0)
                    HuffmanTree[root].rson = pos++;
                root = HuffmanTree[root].rson;
            }
            else
            {
                if(HuffmanTree[root].lson == 0)
                    HuffmanTree[root].lson = pos++;
                root = HuffmanTree[root].lson;
            }
        }
        HuffmanTree[root].v = v;
    }
    
    void print(int zero, int len, char *str)
    {
        long long start = 0;
        int root = 0;
        int end = 0;
        for(int i=0;i<len;i++)
        {
            char t = str[i];
            if(i == len-1)
                end = zero;
            for(int j=7;j>=end;j--)
            {
                if((1<<j) & t)
                    root = HuffmanTree[root].rson;
                else
                    root = HuffmanTree[root].lson;
                if(HuffmanTree[root].lson == 0 && HuffmanTree[root].rson == 0)
                {
                    ans[start++] = HuffmanTree[root].v;
                    root = 0;
                }
            }
        }
        cout<<"len::"<<start<<endl;
        ofstream out(filename, ios::out);
        out.write(ans, sizeof(char)*(start));
        out.close();
    }
    
    int main(int argc, char **argv)
    {
        strcpy(filename, argv[1]);
        filename[strlen(filename)-4] = 'o';
        filename[strlen(filename)-3] = 'u';
        filename[strlen(filename)-2] = 't';
        filename[strlen(filename)-1] = '\0';
    
        ifstream fin(argv[1], ios::in);
        if(!fin)
        {
            cout<<"File open error!"<<endl;
            return 0;
        }
        int num;
        char *t = new char[num];
        char *v = new char[3];
        fin>>num;
        fin.getline(t,num);
        cout<<"size::"<<num<<endl;
        int pos = 1;
        for(int i=1;i<num;i++)
        {
            fin.getline(t,num);
            fin.getline(v,num);
            if(v[0] == '\0')
            {
                fin.getline(v,num);
                v[0] = '\n';    
            }
            CreatTree(t, v[0], pos);
            v[0]=0;
        }
    
        int zero;
        long long size;
        fin>>zero; fin>>size;
        fin.getline(t,num);
        fin.read(str,sizeof(char)*size);
        print(zero, size, str);
    
        cout<<"zero::"<<zero<<endl;
    
        return 0;
    }

    代码读写操作用文件流实现,所以在时间效率方面还有很多可优化的地方,待日后闲了再说,毕竟考试在即。。。如果哪里有错误,欢迎砸砖,便于在下提升修正。

    展开全文
  • 图像压缩编码(哈夫曼树)

    千次阅读 2019-01-16 12:13:28
    1.首先图片压缩编码对不同文件的压缩效率是不一样的  这也是我在最后发现自己的压缩比率超高(类似于未压缩)...不同类型文件压缩比的测试 https://blog.csdn.net/to_be_better/article/details/50431352   ...

    1.首先图片压缩编码对不同文件的压缩效率是不一样的

         这也是我在最后发现自己的压缩比率超高(类似于未压缩)发现的。多次确认算法无误后终于在以为大佬的博客中找到了答案。此处感谢下面这位大佬的博客。

    哈夫曼编码压缩解压缩实现&不同类型文件压缩比的测试

    https://blog.csdn.net/to_be_better/article/details/50431352

     

    2.为什么要用haffman

         对于一组具有确定权值的叶子结点,可以构造出多个具有不

        同带权路径长度的二叉树,我们把其中最小带权路径长度的二叉树称为哈夫曼树。(最优二叉树)。

        哈夫曼树可以用于构造代码长度最短的编码,所以使用哈夫曼树。

    3.生成haffman及haffman编码

        haffman生成:

        其中x1,x2用于存放权值最小的两个节点。

    int cHuffmanTree(HTNode pHT[],int w[],int n){
    	int i,j,m1,m2,x1,x2,t;   
    
    	//初始化
    	for(i=0;i<(2*n-1);i++){
    		if(i<n){
    		    (pHT[i]).weight=w[i];
    			 
    		}
    		else{
    		   (pHT[i]).weight=0;
    		}
    		(pHT[i]).parent=-1;
        	(pHT[i]).lchild=-1;
    	    (pHT[i]).rchild=-1;
    	}
    	 
    	//构造哈夫曼树的n-1个非叶子结点
    	for(i=0;i<n-1;i++){
    	   m1=m2=1000000;            //书上显示=MaxValue
    	   x1=x2=0;
    	   for(j=0;j<n+i;j++){
    		   if(((pHT[j]).weight<m1)&&((pHT[j]).parent==-1)){
    				m2=m1;
    				x2=x1;
    				m1=(pHT[j]).weight;
    				x1=j;
    		   }
    		   else if(((pHT[j]).weight<m2)&&((pHT[j]).parent==-1)){
    			   m2=(pHT[j]).weight;
    			   x2=j;
    		   }
    	   }
    	   
    	   //将找出两颗权值最小和次小的子树合并为一棵树
    	   (pHT[x1]).parent=n+i;
    	   (pHT[x2]).parent=n+i;
    	   (pHT[n+i]).weight=(pHT[x1]).weight+(pHT[x2]).weight;
    	   (pHT[n+i]).lchild=x1;
    	   (pHT[n+i]).rchild=x2;
    	}
    
    	return 0;
    }

         haffman编码生成:

         左0右1原则

    int HuffmanCodeing(HTNode pHT[],Code  pHC[]){
    	Code *cd=(Code *)malloc(sizeof(Code));
    	int i,j,child,parent;
    	int n=256;
    	//求n各节点的哈夫曼编码
    	for(i=0;i<n;i++){
    		cd->start=n-1;
    		cd->weight=pHT[i].weight;
    		child=i;
    		parent=pHT[child].parent;
    
    		//由节点向上直到根节点
    		while(parent!=-1)
    		{
    			if(pHT[parent].lchild==child)
    				cd->bit[cd->start]=0;
    			else
    				cd->bit[cd->start]=1;
    			cd->start--;
    			child=parent;
    			parent=pHT[child].parent;
    		}
    		for(j=cd->start+1;j<n;j++){
    			pHC[i].bit[j]=cd->bit[j];
    			pHC[i].start=cd->start+1;
    			pHC[i].weight=cd->weight;
    		}
    	}
    	return 0;
    }

    4.压缩并计算比率  

    int Compress(const char*pFilename){
    	int i;
    	int nSize=0;
    	HuffmanTree pHT=NULL;
    	HuffmanCode pHC=NULL;
    	char* pBuffer=NULL;
    	
    	HEAD sHead;
    	int len;
    	int ch;
    	FILE* in;
    	 
    	char cd[SIZE]={0}; //工作区
    	int pos=0,j;
    	 
    	
    
    	if(ERROR==InitHead(pFilename,&sHead)){
    		return ERROR;
    	}
    	printf("%d字节\n",sHead.length);
    	pHT=(HuffmanTree)malloc((sizeof(HTNode))*(2*256-1));
    	pHC=(HuffmanCode)malloc((sizeof(Code))*(256));
    	if(pHT==NULL){
    	   printf("初始化失败!\n");
    	   return ERROR;
    	}
    	if(pHC==NULL){
    	   printf("初始化失败!\n");
    	   return ERROR;
    	}
    	//....
    	cHuffmanTree(pHT,sHead.weight,256);
    	HuffmanCodeing(pHT,pHC);
    	free(pHT);
    	// 
    	//计算编码缓冲区大小
    	in=fopen(pFilename,"rb");
    	if(in==NULL){
    	   printf("文件为空\n");
    	   return ERROR;
    	}
    	 while((ch=fgetc(in))!=EOF){
    		//strcat(cd,pHC[ch].bit+'0');
    		 i=0;
    		 for(j=pHC[ch].start;j<256;j++){   //HC复制编码串到cd
    		  cd[i]=pHC[ch].bit[j]+'0';	
    		  i++;
    		 }  		
    		//压缩编码
    		while(strlen(cd)>=8){
    			//截取字符串左边的8个衣服,编码成字节
    			pos++;
    			//字符串正题左移八个字符
    			for(i=0;i<SIZE-8;i++){
    				cd[i]=cd[i+8];
    			}
    		}
    	}
    	fclose(in);
    	if(strlen(cd)>0){
    		pos++;
    	}
    	 
    	/*for(i=0;i<256;i++){
    		nSize+=pHC[i].weight*(256-pHC[i].start);
    		  
    	}
    	nSize=(nSize%8)?(nSize/8+1):nSize/8;*/
    	//对源文件进行压缩编码
    	 nSize=pos;
    	pBuffer=Encode(pFilename,pHC,pBuffer,nSize);
    	free(pHC);
    	if(!pBuffer){
    		printf("失败");
    	    return ERROR;
    	}
    	 
    	len=Write( pFilename, sHead, pBuffer,  nSize);
    	free(pBuffer);
    	if(len<0){
    	    return ERROR;
    	}
    	printf("%d字节\n",len);
    	printf("压缩比率:%f",(double)len/(double)sHead.length*100);
    	putchar('%');
    	printf("\n");
        return 0;
    }

        特别要注意的是在对编码后的文件预算如果像如下所示会造成空间计算偏差,以至于压缩率变大(效率变低),也就是计算错误。经过改进后如上通过pos得出nSize,就可以达到目的。

        /*for(i=0;i<256;i++){
            nSize+=pHC[i].weight*(256-pHC[i].start);
              
        }
        nSize=(nSize%8)?(nSize/8+1):nSize/8;*/

    关于文件的初始化和最重要的压缩码存放在缓冲字符数组的细节就不一一列举了。其实思想蛮简单的,就是:

    1.将对各个字符进行编码。

    2.从文件中再次依次按顺序读出字符,这时注意的是用编码替换文件中的字符。

    3.再按顺序依次一个个八个位转码位字符放入缓冲字符数组中存放。

    4.最后,写入文件,计算出压缩比率。

    展开全文
  • 研究原文件的大小和类型对于压缩文件与原文件大小之的影响。2、 从一本通俗杂志中摘录几段文字,并删除所有不会影响理解的文字,实现压缩。例如,在"this is the dog that belong to my friend” 中,删除 is 、...

    实验一  建立统计压缩方法理论模型 
    一、实验要求
    1、 用你的计算机上的压缩工具来压缩不同文件。研究原文件的大小和类型对于压缩文件与原文件大小之比的影响。
    2、 从一本通俗杂志中摘录几段文字,并删除所有不会影响理解的文字,实现压缩。例如,在"this is the dog that belong to my friend” 中,删除 is 、the、that和to之后,仍然能传递相同的意思。用被删除的单词数与原文本的总单词数之比来衡量文本中的冗余度。用一本技术期刊中的文字来重复这一实验。对于摘自不同来源的文字,我们能否就其冗余度做出定量论述?
    3、 编写一段程序,从包括26个字母的符号集{a,b,...,z}中随机选择字母,组成100个四字母单词,这些单词中有多少是有意义的?


    二、实验内容
    (这里具体描述相对实验要求的内容细节)
    1、实验基本思路/实验平台,含软硬件
    (如:你使用的是何种工具等等内容)
    2、实验准备知识
    (该实验中涉及到的知识点)
    3、实验的具体实现
    (针对实验要求,具体描述实验的步骤或流程。本实验中第三题请附流程图和程序代码。)

    三、实验结果及分析
    (这里给出实验结果,并分析产出该结果的原因和得到的结论或启示。)

    实验报告:

     

    实验报告

     

            姓名:罗丹                  学号:130705010059              专业:数字媒体技术

    一、实验目的

     1.使用压缩工具压缩不同文件,研究原文件的大小和类型对于压缩文件与原文件大小之比的影响。

      2.研究冗余度。

    二、实验内容

      1.实验基本思路/实验平台,含软硬件

       (1)用计算机上的压缩工具来压缩不同文件。研究原文件的大小和类型对于压缩文件与原文件大小之比的影响。

        (2)从一本通俗杂志中摘录几段文字,并删除所有不会影响理解的文字,实现压缩。例如,在"this is the dog that belong to my friend” 中,删除 is 、the、that和to之后,仍然能传递相同的意思。用被删除的单词数与原文本的总单词数之比来衡量文本中的冗余度。用一本技术期刊中的文字来重复这一实验。对于摘自不同来源的文字,就其冗余度做出定量论述。

        (3)编写一段程序,从包括26个字母的符号集{a,b,...,z}中随机选择字母,组成100个四字母单词,探索这些单词中有多少是有意义的。

       2.实验准备知识

         (1)对冗余度等基础概念的理解

         (2)

       3、实验的具体实现(对内容1中设计题设进行具体实现)

          (1)

          (2)

          (3)程序:

    #include<stdio.h>
    #include<stdlib.h>

    int main()
    {
    int count;
    char Word;
    int i=0,j=0;

    while(j<=99)
    {
         printf("%d ",j+1);
         while(i<=3)
         {
             count=rand()%26;
             Word='a'+count;
             printf("%c",Word);
             i++;
         }
       
         printf("\t");
         i=0;
         j++;
    }


    return 0;
    }

    运行结果:

        

    三、实验结果及分析

         1.观察内容3中(1)得出结论:

          文件进行压缩过后比例明显发生了变化,其中压缩比大概是4:1。其次压缩过后传送速度明显会加快,提高了速度减少了空间占比。

          2.观察内容3中(2)得出结论:

           冗余度是指从安全角度考虑多余的一个量,这个量就是为了保障仪器、设备或某项工作在非正常情况下也能正常运转,通俗的讲是数据的重复度。而冗余度小。数据间的关系采用多链表结构,根据实际测试结果,在响应速度规定的范围内可最大限度地减少各种文件的冗余度。

          3.观察内容3中(3)得出结论:

          

     

     

     

     

    转载于:https://www.cnblogs.com/luodandan/p/4876799.html

    展开全文
  • 史上超高压缩软件2009

    2009-09-04 14:46:16
    上一个正式版有了质的飞跃,默认压缩模式0的压缩率已经完全战胜UHARC,速度原来 的模式3仅慢了不到10%.并大大减轻高模式的内存占用过多耗时过多的问题. 比较上一版本(0.250),速度有了10%的提升,程序又减少了1KB...
  • 游戏的资源文件和一些常见的压缩文件如Winzip和Winrar一样,游戏资源文件包含了一些小文件。这个资源文件就像一个大的箱子,箱子里面可以存储大量不同的物品,而且每个物品的类型都不一样。游戏的资源文件是一个虚拟...
    游戏的资源文件和一些常见的压缩文件如Winzip和Winrar一样,游戏资源文件包含了一些小文件。这个资源文件就像一个大的箱子,箱子里面可以存储大量不同的物品,而且每个物品的类型都不一样。游戏的资源文件是一个虚拟的文件系统,也有人将它们称为归档、打包文件或封包文件。虚拟的文件系统和操作系统的文件系统一样都可以存储和定位文件,游戏使用的资源文件系统比操作系统的文件系统简单。
    在游戏开发过程中,游戏使用的资源文件多数都是不需要打包成归档的,因为在游戏开发期间游戏使用的资源文件常常需要频繁地修改,而在游戏发布最终版本时游戏开发人员常会因为如下原因将游戏使用的资源文件打包成归档。
    (1)加快文件读取速度。
    将多个单独的资源文件打包成一个归档文件可以利用索引ID快速定位读取游戏所需要的资源,相对操作系统的文件系统而言,操作系统定位一个文件是使用文件名路径字符串,而游戏的资源文件包是使用数字索引ID定位文件,而且资源文件里的索引ID一般都是排序过的,这样对资源文件的搜索和定位就更快了。从操作系统的设计上来说,操作系统的文件系统要比游戏使用的文件系统要复杂得多,一般越复杂的东西就需要越多的CPU时间处理,所以将资源文件打包可以加快游戏读取资源文件的速度。
    (2)有效利用缓存。
    和系统中的cache缓存一样,游戏引擎可以利用文件系统高速缓存来提高读写文件速度。大家都知道硬盘的读写速度相对内存而言是非常慢的,因为这个原因所以提出了文件系统高速缓存。
    文件系统高速缓存会加快从硬盘到主内存的数据传输,文件系统高速缓存其实就是系统内存开辟的一个区域,由于将各个小资源文件打包成一个较大的归档文件,所以缓存的利用率被提高了。
    (3)减少文件操作。
    将各个小资源文件打包成一个归档文件后,游戏调用资源文件时只需要进行一次打开归档文件的I/O操作,因为文件I/O操作是一个相对花费时间的操作,而游戏需要的响应速度需求是极高的,没有玩家愿意接受在一台配置最新的计算机上玩游戏时看见游戏卡住不动的。
    (4)存储多个单独的文件。
    将多个单独的文件暴露在发布的光盘中会让人觉得游戏开发人员不够专业,而且很容易让玩家修改游戏中重要的数据文件。一般情况下玩家修改游戏的图片、音乐、动画对游戏的影响并不大,但如果玩家修改一些重要的剧情脚本文件的话,可能会出现游戏逻辑上的错误,从而导致游戏引擎出错,这是游戏开发人员不愿意看到的。
    (5)减少碎片。
    操作系统以簇的大小为单位存储文件,一般Windows中标准的簇大小为4.096KB/簇,也就是说一个少于4.096KB的文件也需要占用4.096KB。簇的大小是由文件系统格式决定的,常见的文件系统格式有FAT32和NTFS。对于FAT32来说,如果一个分区少于8GB,则簇的大小为4.096KB。如果一个分区大于8GB,那么簇的大小就会成倍增加,也就是说在FAT32下一个分区越大,簇的大小就越大,文件占用的空间也越多。除非文件的大小正好和簇的大小的倍数一致才不会浪费空间,这些不能再使用的空间称为碎片。因为操作系统目前还没有一种可以完全解决磁盘碎片的办法,所以存储文件无可避免会浪费一些硬盘存储空间。由于将资源文件打包成一个大的归档文件时,归档里的各个小资源文件一般都是连续存储的,因此减少了存储文件产生的碎片,节约了存储空间。
    (6)保护资源文件。
    将资源文件打包成一个归档文件后,由于这个归档文件没有固定的存储格式,所以对于一般的玩家而言就不能修改游戏中重要的数据文件,也就是为什么玩家通常在游戏的目录文件中找不到游戏使用的图片、音乐和动画等一些资源文件了,这样就很好地保护了游戏中的资源文件。
    (7)加密和压缩资源文件。
    将资源文件打包可以更有效地使用加密和压缩处理各个资源文件,一般来说游戏开发人员开发游戏引擎时都会开发一些辅助工具,这些辅助工具中有一个叫资源文件打包器的工具。资源文件打包器作用是将单独的资源文件打包成一个大的归档文件,而且可以针对每个文件或全部文件使用一种或多种的加密和压缩方法处理,游戏使用的资源文件如图像可以利用一些常见的压缩算法有效地压缩。例如假设游戏的图片资源文件一共2GB,但使用了RLE压缩编码压缩过后可能只有500MB,虽然游戏引擎读取资源文件时需要花费解码的时间,但实际上读取一个500MB的文件加上解码所花费的时间还是远远少于读取一个2GB的图片资源文件所花的时间。

    以上章节来自:
    http://book.51cto.com/art/200903/112672.htm
    《揭秘数据解密的关键技术》 刘颖东
    本书是一本以游戏资源文件格式为研究对象的数据逆向工程的技术书籍,主要讲解如何分析和研究自定义文件格式的数据结构。本书内容包含反汇编的阅读和理解,数据在计算机中的存储原理,常用媒体格式的解析,加密和解密的识别和分析,数据压缩的特征识别,打包文件格式的识别和游戏窗口化的方法。本书对每一个问题都给出了详细和完整的分析过程,力求用最通俗和简单的方法让读者学会分析和研究自定义文件格式。
    本书适合对数据解密、游戏资源提取、软件逆向工程感兴趣的读者以及广大编程爱好者阅读。

    转载于:https://www.cnblogs.com/lancidie/archive/2010/12/03/1895135.html

    展开全文
  • 向现有映像文件添加新的映像卷时,WimTool会自动检测原映像文件的压缩类型,并使新加入的映像卷与之匹配。 3、支持挂载和卸载Wim文件。用WimTool挂载Wim文件时,用户可以选择指定的映像文件和挂载目录,同时也可...
  • 实验一

    2016-09-18 21:33:00
    1、用你的计算机上的压缩工具来压缩不同文件。研究原文件的大小和类型对于压缩文件与原文件大小之的影响。 答:经试验发现原文件的大小和类型对于压缩文件与原文件大小之有影响,特别是TXT类型的,压缩文件与原...
  • clpdcopy.ZIP 一个可以从剪贴版粘贴文件的程序(象Explore中的“复制”和“粘贴”一样)(4KB) 10,findfile.ZIP 利用递归方式实现对文件的查找操作(3KB) 11,vb52unix.ZIP 将VB格式文件转换为Unix...
  • 今天要下载gcc编译器,在download页面发现有两种类型的下载格式:.tar.gz和.tar.bz2,不知道要下载哪个,而且这两种格式在Linux中也很常用,于是搜索一下。...bz2的压缩比要比gzip的压缩比高一些。
  • WINRAR5.0正式注册版

    2013-10-10 10:14:03
    b) RAR 5.0 的默认字典大小是 32MB,结果就是 RAR 4.x 的 4MB 更高的压缩率和较 慢的速度。你可以在压缩对话框选择中使用“字典大小”选项或 -md<大小> 开关修 改此值; c) -md<大小> 开关的语法修改为支持更...
  • 第一次作业续

    2015-09-02 11:05:00
    研究原文件的大小和类型对于压缩文件与原文件大小之的影响。 答: 视频文件的大小一般是和质量有关的,常见的有帧率码率等数据就是描述视频质量的一般来说,rmvb格式的相对较小,但是质量有一定损失 2. 并不...
  • 第一次实验

    2015-10-14 10:33:00
    研究原文件的大小和类型对于压缩文件与原文件大小之的影响。2、 从一本通俗杂志中摘录几段文字,并删除所有不会影响理解的文字,实现压缩。例如,在"this is the dog that belong to my friend” 中,删除 is 、...
  • 第一次试验

    2015-10-14 10:40:00
    研究原文件的大小和类型对于压缩文件与原文件大小之的影响。2、 从一本通俗杂志中摘录几段文字,并删除所有不会影响理解的文字,实现压缩。例如,在"this is the dog that belong to my friend” 中,删除 is 、...
  • Zipx 格式的文件是 WinZip 特有的一种压缩格式,这种压缩格式优势在于,针对不同的文件,采用不用的压缩算法,用最佳的方式提供问文件的压缩比率。使用最佳方式创建的 Zipx 文件 Zip 文件的大小更小。尤其当你有很...
  • 记excel小事

    2019-06-26 10:56:00
    xlsx 的核心结构是 XML 类型的结构,采用的是基于 XML 的压缩方式,使其占用的空间更小。(这一点是我才开始很纠结的地方,线上报错的excel文件,我在我自己的电脑上复制到另外一个excel,大小立马缩小了很多,当时...
  • 支持文件加密,加密文件和文件夹到多种不同的安全格式,修复压缩文档,修复一个损坏的ZIP压缩文档以便可以打开,写入多卷ZIP,分卷原始ZIP文件为多个较小的压缩文档,合并多卷ZIP,合并分卷到一个单一ZIP压缩文档中...
  • winrar3.7 Beta8

    2007-07-07 00:17:02
    它提供了其它 PC 压缩工具更高 的压缩率,特别适用于处理可执行文件,对象库,大的文本文件等。 <br> * WinRAR 提供了一个可选的,对多媒体数据高度优化的压缩运算法。 <br> * WinRAR 支持文件和压缩...
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    在.aspx页面中,代码隐藏页模型.aspx页面代码基本上和单文件页模型代码相同,不同的是在script标记中文件页模型代码默认被放在了同名.cs文件中,.aspx文件示例代码如下所示。 “C#” AutoEventWireup=...
  • 软件完美支持RAR 和 ZIP ,还支持CAB、ARJ、LZH、TAR、GZ、ACE、UUE、BZ2、JAR、ISO 等多种类型的压缩文件;可以实现多卷压缩功能,具有历史记录和收藏夹功能、创建自释放文件,可以制作简单的安装程序等强大的功能...
  • avg8.0汉化包

    2009-03-14 10:30:34
     支持新的文件类型和存档格式  新模拟器,允许更有效启发式分析  更低内存消耗  支持多线程多核心中央处理器  无缝运行于众多操作系统  可用于32位和64位Windows  注:Linux,FreeBSD版本在...
  • 介绍 相当于Linux中的文件系统.存储引擎就是MySQL中的文件系统.负责和"磁盘"打交道 类型 支持多种存储引擎.插件式.针对不同表可以使用不同的存储引擎. 5.5 版本开始,用户自定义表,默认是... 高压缩比 b. Inser..
  • day05-存储引擎

    2021-01-05 21:02:22
    存储引擎 介绍 相当于Linux中的文件系统.存储引擎就是MySQL中的文件系统.负责和"磁盘"打交道 类型 支持多种存储引擎.插件式.针对不同表可以使用不同的存储引擎. 5.5 版本开始,用户自定义表,默认是... 高压缩比 25倍 b.
  • 视光盘容量,CDRW一般不超过650MB,CDR一般不超过700MB,已加入文件的大小总值在nero主界面的最下面有刻度显示。 需要特别说明的: ①在nero的刻录界面里是看不到开始时加入的ima文件内容的,因为这个ima文件已被...
  • Go 写独立可执行文件)不需要任何类型的数据存储维护状态或历史记录可以由多个开发人员同时使用,不会有锁定或不一致状态危险正确处理缓存头支持无冲突部署多个项目到同一网站的不同子目录压缩文件传输更快 ...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

不同类型文件的压缩比不同