跳转到内容

std.compress.flate

标准库Zig 0.17.1官方原文
源码std/compress/flate.zig

第 1 行

std.compress.flate.Compress

别名

第 11 行

Deflate 是一种无损数据压缩文件格式, 结合使用 LZ77 与 Huffman 编码。

别名目标 std.compress.flate.Compress

std.compress.flate.Container

容器

第 29 行

deflate 位流主体的容器。容器在 deflate 位流之前添加头部, 在其之后添加尾部。可以是 gzip、zlib 或 raw,即无头部、 无尾部的原始位流。

zlib 格式定义于 RFC 1950。头部为 2 字节,尾部为 4 字节的 Adler-32 校验和。

gzip 格式定义于 RFC 1952。头部至少为 10 字节,尾部包含 4 字节的 CRC32 校验和及 4 字节的未压缩数据长度。

rfc 1950:https://datatracker.ietf.org/doc/html/rfc1950#page-4 rfc 1952:https://datatracker.ietf.org/doc/html/rfc1952#page-5

字段

raw
gzip
zlib

std.compress.flate.Container.Error

错误集合

第 52 行

错误

BadGzipHeader
BadZlibHeader
WrongGzipChecksum
WrongGzipSize
WrongZlibChecksum

std.compress.flate.Container.footerSize

函数

第 42 行

pub fn footerSize(w: Container) usize

参数

std.compress.flate.Container.Hasher

容器

第 86 行

字段

raw: void
gzip: struct {
    crc: std.hash.Crc32 = .init(),
    count: u32 = 0,
}
zlib: std.hash.Adler32

std.compress.flate.Container.Hasher.container

函数

第 102 行

pub fn container(h: Hasher) Container

参数

h: Hasher

std.compress.flate.Container.Hasher.init

函数

第 94 行

pub fn init(containter: Container) Hasher

参数

containter: Container

std.compress.flate.Container.Hasher.update

函数

第 106 行

pub fn update(h: *Hasher, buf: []const u8) void

参数

h: *Hasher
buf: []const u8

std.compress.flate.Container.Hasher.writeFooter

函数

第 119 行

pub fn writeFooter(hasher: *Hasher, writer: *std.Io.Writer) std.Io.Writer.Error!void

参数

hasher: *Hasher
writer: *std.Io.Writer

错误

WriteFailed

详细诊断信息见 Writer 实现。

std.compress.flate.Container.header

函数

第 60 行

pub fn header(container: Container) []const u8

参数

container: Container

std.compress.flate.Container.headerSize

函数

第 38 行

pub fn headerSize(w: Container) usize

参数

std.compress.flate.Container.list

常量

第 50 行

std.compress.flate.Container.Metadata

容器

第 142 行

字段

raw: void
gzip: struct {
    crc: u32 = 0,
    count: u32 = 0,
}
zlib: struct {
    adler: u32 = 0,
}

std.compress.flate.Container.Metadata.container

函数

第 160 行

pub fn container(m: Metadata) Container

参数

std.compress.flate.Container.Metadata.init

函数

第 152 行

pub fn init(containter: Container) Metadata

参数

containter: Container

std.compress.flate.Container.size

函数

第 34 行

pub fn size(w: Container) usize

参数

std.compress.flate.Decompress

别名

第 15 行

Inflate 是解码过程,消耗 Deflate 位流, 产生原始完整大小的数据。

别名目标 std.compress.flate.Decompress

std.compress.flate.history_len

常量

第 7 行

std.compress.flate.max_window_len

常量

第 5 行

压缩和解压时,给定缓冲区用作 历史窗口,因此其大小必须至少达到此值。

std.compress.flate.std

别名

第 1 行

别名目标 std

源码

std/compress/flate.zig

const std = @import("../std.zig");

/// 压缩和解压时,给定缓冲区用作
/// 历史窗口,因此其大小必须至少达到此值。
pub const max_window_len = history_len * 2;

pub const history_len = 32768;

/// Deflate 是一种无损数据压缩文件格式,
/// 结合使用 LZ77 与 Huffman 编码。
pub const Compress = @import("flate/Compress.zig");

/// Inflate 是解码过程,消耗 Deflate 位流,
/// 产生原始完整大小的数据。
pub const Decompress = @import("flate/Decompress.zig");

/// deflate 位流主体的容器。容器在 deflate 位流之前添加头部,
/// 在其之后添加尾部。可以是 gzip、zlib 或 raw,即无头部、
/// 无尾部的原始位流。
///
/// zlib 格式定义于 RFC 1950。头部为 2 字节,尾部为 4 字节的
/// Adler-32 校验和。
///
/// gzip 格式定义于 RFC 1952。头部至少为 10 字节,尾部包含 4 字节的
/// CRC32 校验和及 4 字节的未压缩数据长度。
///
/// rfc 1950:https://datatracker.ietf.org/doc/html/rfc1950#page-4
/// rfc 1952:https://datatracker.ietf.org/doc/html/rfc1952#page-5
pub const Container = enum {
    raw, // 无头部或尾部
    gzip, // gzip 头部和尾部
    zlib, // zlib 头部与尾部

    pub fn size(w: Container) usize {
        return headerSize(w) + footerSize(w);
    }

    pub fn headerSize(w: Container) usize {
        return header(w).len;
    }

    pub fn footerSize(w: Container) usize {
        return switch (w) {
            .gzip => 8,
            .zlib => 4,
            .raw => 0,
        };
    }

    pub const list = [_]Container{ .raw, .gzip, .zlib };

    pub const Error = error{
        BadGzipHeader,
        BadZlibHeader,
        WrongGzipChecksum,
        WrongGzipSize,
        WrongZlibChecksum,
    };

    pub fn header(container: Container) []const u8 {
        return switch (container) {
            // GZIP 的 10 字节头部(https://datatracker.ietf.org/doc/html/rfc1952#page-5):
            //  - ID1,标识 1,始终为 0x1f
            //  - ID2,标识 2,始终为 0x8b
            //  - CM,压缩方法,始终为 8 = deflate
            //  - FLG,标志,全部设为 0
            //  - 4 字节 MTIME,修改时间,未使用,全部设为零
            //  - XFL,额外标志,全部设为零
            //  - OS,操作系统,03 = Unix
            .gzip => &[_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 },
            // ZLIB 有一个双字节报头(https://datatracker.ietf.org/doc/html/rfc1950#page-4):
            // 第一个字节:
            //  - 前四位为 CINFO,即压缩信息;默认 deflate 窗口大小对应 7。
            //  - 后四位为 CM,即压缩方法;deflate 对应 8。
            // 第二个字节:
            //  - 两位为 FLEVEL,即压缩级别,值为:0=最快,1=快速,2=默认,3=最佳。
            //  - 下一位 FDICT 在提供字典时置位。
            //  - 最后五位 FCHECK 构成模 31 校验和。
            //
            // CINFO = 7, CM = 8, FLEVEL = 0b10, FDICT = 0, FCHECK = 0b11100
            .zlib => &[_]u8{ 0x78, 0b10_0_11100 },
            .raw => &.{},
        };
    }

    pub const Hasher = union(Container) {
        raw: void,
        gzip: struct {
            crc: std.hash.Crc32 = .init(),
            count: u32 = 0,
        },
        zlib: std.hash.Adler32,

        pub fn init(containter: Container) Hasher {
            return switch (containter) {
                .gzip => .{ .gzip = .{} },
                .zlib => .{ .zlib = .{} },
                .raw => .raw,
            };
        }

        pub fn container(h: Hasher) Container {
            return h;
        }

        pub fn update(h: *Hasher, buf: []const u8) void {
            switch (h.*) {
                .raw => {},
                .gzip => |*gzip| {
                    gzip.crc.update(buf);
                    gzip.count +%= @truncate(buf.len);
                },
                .zlib => |*zlib| {
                    zlib.update(buf);
                },
            }
        }

        pub fn writeFooter(hasher: *Hasher, writer: *std.Io.Writer) std.Io.Writer.Error!void {
            switch (hasher.*) {
                .gzip => |*gzip| {
                    // GZIP 的 8 字节尾部
                    //  - 4 字节,CRC32(CRC-32)
                    //  - 4 字节,ISIZE(输入大小):原始未压缩输入数据的大小对 2^32 取模
                    //
                    try writer.writeInt(u32, gzip.crc.final(), .little);
                    try writer.writeInt(u32, gzip.count, .little);
                },
                .zlib => |*zlib| {
                    // ZLIB(RFC 1950)采用大端,与 GZIP(RFC 1952)不同。
                    // 4 字节 ADLER32(Adler-32 校验和)。
                    // 根据 Adler-32 算法计算的未压缩数据
                    // 校验和值,不包括任何
                    // 字典数据。
                    try writer.writeInt(u32, zlib.adler, .big);
                },
                .raw => {},
            }
        }
    };

    pub const Metadata = union(Container) {
        raw: void,
        gzip: struct {
            crc: u32 = 0,
            count: u32 = 0,
        },
        zlib: struct {
            adler: u32 = 0,
        },

        pub fn init(containter: Container) Metadata {
            return switch (containter) {
                .gzip => .{ .gzip = .{} },
                .zlib => .{ .zlib = .{} },
                .raw => .raw,
            };
        }

        pub fn container(m: Metadata) Container {
            return m;
        }
    };
};

test {
    _ = Compress;
    _ = Decompress;
}