package core:compress/zlib

Source

Compression_Level :: enum u8 {
	Fastest = 0, 
	Fast    = 1, 
	Default = 2, 
	Maximum = 3, 
}

Compression_Method :: enum u8 {
	DEFLATE  = 8, 
	Reserved = 15, 
}

Deflate_Error :: compress.Deflate_Error

Error :: compress.Error

General_Error :: compress.General_Error

Huffman_Table :: struct {
	fast:        [512]u16,
	firstcode:   [17]u16,
	maxcode:     [17]int,
	firstsymbol: [17]u16,
	size:        [288]u8,
	value:       [288]u16,
}

Options :: struct {
	window_size: u16,
	level:       u8,
}

ZLIB_Error :: compress.ZLIB_Error

DEFLATE_MAX_CHUNK_SIZE :: 65535

DEFLATE_MAX_DISTANCE :: 32768

DEFLATE_MAX_LENGTH :: 258

DEFLATE_MAX_LITERAL_SIZE :: 65535

HUFFMAN_FAST_BITS :: 9

HUFFMAN_FAST_MASK :: (1 << HUFFMAN_FAST_BITS) - 1

HUFFMAN_MAX_BITS :: 16

ZFAST_BITS :: 9

ZFAST_MASK :: (1 << ZFAST_BITS) - 1

Z_DIST_BASE: [32]u16 = …

Z_DIST_EXTRA: [32]u8 = …

Z_FIXED_DIST: [32]u8 = …

Z_FIXED_LENGTH: [288]u8 = …

Z_LENGTH_BASE: [31]u16 = …

Z_LENGTH_DEZIGZAG: []u8 = …

Z_LENGTH_EXTRA: [31]u8 = …

allocate_huffman_table :: proc(allocator := context.allocator) -> (z: ^Huffman_Table, err: compress.Error) {…}

build_huffman :: proc(z: ^Huffman_Table, code_lengths: []u8) -> (err: compress.Error) {…}

decode_huffman :: proc(z: ^$T, t: ^Huffman_Table) -> (r: u16, err: compress.Error) {…}

decode_huffman_slowpath :: proc(z: ^$T, t: ^Huffman_Table) -> (r: u16, err: compress.Error) {…}

grow_buffer :: proc(buf: ^[dynamic]u8) -> (err: compress.Error) {…}

inflate_from_byte_array :: proc(input: []u8, buf: ^bytes.Buffer, raw: bool = false, expected_output_size: int = -1) -> (err: compress.Error) {…}

inflate_from_byte_array_raw :: proc(input: []u8, buf: ^bytes.Buffer, raw: bool = false, expected_output_size: int = -1) -> (err: compress.Error) {…}

inflate_from_context :: proc( using ctx: ^compress.Context_Memory_Input, raw: bool = false, expected_output_size: int = -1, allocator := context.allocator) -> (err: compress.Error) {…}

inflate_raw :: proc(z: ^$T, expected_output_size: int = -1, allocator := context.allocator) -> (err: compress.Error) {…}

parse_huffman_block :: proc(z: ^$T, z_repeat, z_offset: ^Huffman_Table) -> (err: compress.Error) {…}

repl_byte :: proc(z: ^$T, count: u16, c: u8) -> (err: io.Error) {…}

repl_bytes :: proc(z: ^$T, count: u16, distance: u16) -> (err: io.Error) {…}

write_byte :: proc(z: ^$T, c: u8) -> (err: io.Error) {…}

z_bit_reverse :: proc(n: u16, bits: u8) -> (r: u16) {…}

inflate :: proc{
	inflate_from_context,
	inflate_from_byte_array,
}