精华内容
下载资源
问答
  • nginx配置gzip压缩类型

    千次阅读 2018-09-06 10:50:47
    如果你不知道文件类型是什么,怎么加gzip类型呢? 通过curl来访问,就可以看到Content-Type: application/json # curl -I "https://res.uouo123.com/blog_1.json" HTTP...

    如果你不知道文件类型是什么,怎么加gzip类型呢?

    通过curl来访问,就可以看到Content-Type: application/json

    # curl -I "https://res.uouo123.com/blog_1.json"                                                                           HTTP/1.1 200 OK

    Server: DnionOS/1.11.2.4_7

    Date: Mon, 09 Jul 2018 09:08:54 GMT

    Content-Type: application/json

    Content-Length: 672

    Connection: keep-alive

    Last-Modified: Mon, 12 Jun 2017 08:49:22 GMT

    ETag: "593e5592-2a0"

    Expires: Mon, 02 Jul 2018 08:20:53 GMT

    Cache-Control: max-age=2592000

    Access-Control-Allow-Origin: *

    Access-Control-Allow-Headers: X-Requested-With

    Access-Control-Allow-Methods: GET,POST,OPTIONS

    Accept-Ranges: bytes

    Age: 2061570

    Via: CT-JSNT-P-221-85 (DLC-3.0), CT-GDFS-C-236-68 (DLC-3.0)

    HitType: TCP_MEM_HIT

    Server-Info: DnionATS

    展开全文
  • 可以使用ffmpeg重新压缩,比如: ffmpeg -i origin.mp4 output.mp4 之后使用pr打开output即可。

    可以使用ffmpeg重新压缩,比如:

    ffmpeg -i origin.mp4  output.mp4
    

    之后使用pr打开output即可。

    展开全文
  • 哈夫曼编码一个很重要的特性:每个字符编码不会成为另一个编码的前缀。这个特性保证了即使我们把不同长度的编码存在一起,仍然也可以把它们分离开,不会出现认错人的冲突。 那么我们就可以把所有

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

    压缩原理及步骤

    压缩的第一步:

    将一个文件以各个字符出现的次数为权值建立哈夫曼树,这样每个字符可以用从树根到该字符所在到叶子节点的路径来表示。(左为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;
    }

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

    展开全文
  • 压缩指针这个属性默认是打开的,可以通过-XX:-UseCompressedOops关闭。 首先说一下为何需要压缩指针呢?32 位的存储,可以描述多大的内存呢?假设每一个1代表1字节,那么可以描述 0~2^32-1 这 2^32 字节也就是 4 GB ...

    压缩指针这个属性默认是打开的,可以通过-XX:-UseCompressedOops关闭。

    首先说一下为何需要压缩指针呢?32 位的存储,可以描述多大的内存呢?假设每一个1代表1字节,那么可以描述 0~2^32-1 这 2^32 字节也就是 4 GB 的内存。

    image

    但是呢,Java 默认是 8 字节对齐的内存,也就是一个对象占用的空间,必须是 8 字节的整数倍,不足的话会填充到 8 字节的整数倍。也就是其实描述内存的时候,不用从 0 开始描述到 8(就是根本不需要定位到之间的1,2,3,4,5,6,7)因为对象起止肯定都是 8 的整数倍。所以,2^32 字节如果一个1代表8字节的话,那么最多可以描述 2^32 * 8 字节也就是 32 GB 的内存。

    image

    这就是压缩指针的原理。如果配置最大堆内存超过 32 GB(当 JVM 是 8 字节对齐),那么压缩指针会失效。 但是,这个 32 GB 是和字节对齐大小相关的,也就是-XX:ObjectAlignmentInBytes配置的大小(默认为8字节,也就是 Java 默认是 8 字节对齐)-XX:ObjectAlignmentInBytes可以设置为 8 的整数倍,最大 128。也就是如果配置-XX:ObjectAlignmentInBytes为 24,那么配置最大堆内存超过 96 GB 压缩指针才会失效。

    编写程序测试下:

    A a = new A();
    System.out.println("------After Initialization------\n" + ClassLayout.parseInstance(a).toPrintable());
    

    首先,以启动参数:-XX:ObjectAlignmentInBytes=8 -Xmx16g执行:

    ------After Initialization------
    com.hashjang.jdk.TestObjectAlign$A object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           48 72 06 00 (01001000 01110010 00000110 00000000) (422472)
         12     4        (alignment/padding gap)                  
         16     8   long A.d                                       0
    Instance size: 24 bytes
    Space losses: 4 bytes internal + 0 bytes external = 4 bytes total
    

    可以看到类型字大小为 4 字节48 72 06 00 (01001000 01110010 00000110 00000000) (422472),压缩指针生效。

    首先,以启动参数:-XX:ObjectAlignmentInBytes=8 -Xmx32g执行:

    ------After Initialization------
    com.hashjang.jdk.TestObjectAlign$A object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           a0 5b c6 00 (10100000 01011011 11000110 00000000) (12999584)
         12     4        (object header)                           b4 02 00 00 (10110100 00000010 00000000 00000000) (692)
         16     8   long A.d                                       0
    Instance size: 24 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    

    可以看到类型字大小为 8 字节,压缩指针失效:

    a0 5b c6 00 (10100000 01011011 11000110 00000000) (12999584)
    b4 02 00 00 (10110100 00000010 00000000 00000000) (692)
    

    修改对齐大小为 16 字节,也就是以-XX:ObjectAlignmentInBytes=16 -Xmx32g执行:

    ------After Initialization------
    com.hashjang.jdk.TestObjectAlign$A object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           48 72 06 00 (01001000 01110010 00000110 00000000) (422472)
         12     4        (alignment/padding gap)                  
         16     8   long A.d                                       0
         24     8        (loss due to the next object alignment)
    Instance size: 32 bytes
    Space losses: 4 bytes internal + 8 bytes external = 12 bytes total
    

    可以看到类型字大小为 4 字节48 72 06 00 (01001000 01110010 00000110 00000000) (422472),压缩指针生效。

    每日一刷,轻松提升技术,斩获各种offer:

    image

    展开全文
  • Unity 之 纹理类型导入设置和压缩格式介绍

    千次阅读 多人点赞 2021-09-23 21:46:38
    你知道纹理导入正确设置和各平台压缩格式吗?本文教你如何将纹理资源导入到Unity并为其设置为对应平台需要使用的压缩格式,一起来看看吧~
  • 可以根据图片边长或大小来压缩 import com.dongxu.insurance.service.BASE64DecodedMultipartFile; import net.coobird.thumbnailator.Thumbnails; import org.slf4j.Logger; import org.slf4j.LoggerFactory; ...
  • 需求场景:利用input 上传文件,限制文件类型为zip,或者rar压缩包类型。①尝试通过accept限制,发现除了zip和rar文件,excel,doc等文件也能选择。②于是,解决方案是通过对文件名的判断,增加一层过滤,代码如下...
  • MATLAB数字信号处理(2)LFM脉冲雷达回波处理仿真

    万次阅读 多人点赞 2019-03-13 15:41:24
    线性调频(LFM)信号是应用广泛的一种波形,主要优点是脉冲压缩的形状和信噪比对多普勒频移不敏感,即在目标速度未知的情况下,用匹配滤波器仍可以实现回波信号的脉冲压缩,这将大大有利于雷达对目标的探测和信号...
  • C#string类型压缩,最低能压缩多少????????????????????
  • 索引压缩

    千次阅读 2017-08-10 16:59:27
    当待搜索的数据量极为庞大时,数据所对应的索引的...为了解决这样的问题,学者们提出了一系列的索引压缩技术。 实际上,我们所要处理的数据类型多如牛毛,根据不同的要求,为这些数据设计的索引更是千变万化,最常见
  • jQuery 中压缩版和未压缩什么区别
  • 判断压缩文件的类型。我用了ContentType,输出他的ContentType为null。用文件头判断只有rar和zip,不全面。 还有什么方法能判断出他的类型呢?要准确,还能判断出各种压缩文件类型
  • java压缩图片文件大小

    热门讨论 2014-05-14 11:10:20
    java 开发压缩图片文件大小,2m-->200k 不是压缩宽高的
  • 压缩与限幅
  • 几种压缩算法

    千次阅读 2018-01-24 16:37:37
    一、 行程长度压缩  原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。 例如:aaabccccccddeee,则可用3a1b6c2d3e来代替。对于拥有大面积,相同颜色区域的图像, 用RLE压缩方法...
  • ClickHouse数据的压缩和原理

    千次阅读 2021-04-19 11:29:48
    clickhouse 建表的列压缩算法 ClickHouse服务为了节省磁盘空间,会使用高性能压缩算法对存储的数据进行压缩。...$column_name [type] COCEC($算法类型) ## 修改 ALTER TABLE $table_name MODIFY COLUMN $column_n
  • Hive压缩说明

    千次阅读 2016-11-13 21:50:18
    Hive压缩使用
  • C++ 图像压缩算法

    热门讨论 2014-03-17 22:14:28
    基于C++的图像压缩算法,可以压缩多种类型的图片,可调压缩
  • br压缩算法

    千次阅读 2020-03-29 12:27:56
    虽然Brotli 还是非主流,但是如新贴吧知乎就支持Brotli压缩。谷歌也提供了nginx Brotli 模块。开启方面也不用费什么力。而且cloudflare默认就提供这个支持。本文就Brotli做一些概述性科普和配置实践方法 “智能压缩...
  • 时候,需要对某个文件夹内的某个类型的文件进行压缩。由于使用tar压缩时会把绝对路径也压缩进去,这时解压缩则会多出这些文件夹结构,很麻烦,那么使用如下命令: tar -C /dir1/dir2 -czvf /dir3/dir4/my.tar...
  • hive 压缩格式汇总

    千次阅读 2019-03-01 16:31:32
    今天,看了几篇hive压缩格式相关的博客觉得不错,在这里做一下提取要点汇总。 0 前言 数据做压缩和解压缩会增加CPU的开销,但可以最大程度的减少文件所需的磁盘空间和网络I/O的开销,所以最好对那些I/O密集型的...
  • 视频压缩基本概念

    万次阅读 多人点赞 2018-08-21 09:28:09
    视频压缩基本概念 为什么需要压缩视频 首先回答why这个问题。 假设一个2小时未压缩的高清视频,1920×1080p的电影,我们来计算一下他的存储容量。先介绍一下帧率(frame rate或者是 FPS)概念,也就是每秒传输图片的...
  • 图像有损压缩与无损压缩Lossy and lossless compression are two kinds of data compression techniques. Here in this article, you will get to learn about what is lossy and lossless compression, their ...
  • *.tar 使用 tar –xvf 解压*.tar.gz和*.tgz 使用 tar –zxvf 解压*.gz 使用 gzip -d或者gunzip 解压*.bz2 使用 bzip2 -d 或者 使用 bunzip2 解压*.zip 用 unzip 解压*.tar.bz2 使用 tar –xvjf 解压*.rar 用 unrar e...
  • Bitmap 的四种压缩方式详解

    千次阅读 2019-09-13 12:24:22
    文章目录一、质量压缩二、采样率三、缩放法四、RGB_565 Android 中图片是以 bitmap 形式存在的,那么 bitmap 所占内存,直接影响到了应用所占内存大小,首先要知道 bitmap 所占内存大小计算方式: 像素数 x 像素...
  • 生成tar包后,就可以用其它的程序来进行压缩了,tar命令本身不进行数据压缩,但可以在打包或解包的同时调用其它的压缩程序,比如调用gzip、bzip2 选项: -c 创建.tar格式包文件 -x 解开.tar格式包文件 -v显示详细...
  • 设置inSampleSize的值(int类型)后,假如设为2,则宽和高都为原来的1/2,宽高都减少了,自然内存也降低了。 我上面的代码没用过options.inJustDecodeBounds = true; 因为我是固定来取样的数据,为什么这个压缩...
  • 1.为什么要进行压缩? 在实际的企业当中,nginx服务器上的资源要尽可能的占用的空间少一点 实际上信息量大的网页和高清图片占用存储空间是非常大的,这样不利于服务器性能的优化 因此我们要在服务器上面将网页和图片...
  • 1.压缩概述 数据压缩这是mapreduce的一种优化策略:通过压缩编码对mapper或者reducer的输出进行压缩,以减少磁盘IO,提高MR程序运行速度(但相应增加了cpu运算负担) Mapreduce支持将map输出的结果或者reduce...
  • @echo off setlocal enabledelayedexpansion rem winrar安装目录,我的在D盘且目录为下 ...rem 需要压缩的文件所在目录 set a=D:\dmp set c=0 for %%k in (%a%\*.sql*) do ( set /a c+=1 WinRAR a -r -ep "%~dp0%%~nk.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 528,904
精华内容 211,561
关键字:

压缩类型有