package core:compress

Source

Context_Memory_Input :: struct #packed {
	input_data:    []u8,
	output:        ^bytes.Buffer,
	bytes_written: i64,
	code_buffer:   u64,
	num_bits:      u64,
	size_packed:   i64,
	size_unpacked: i64,
}

Context_Stream_Input :: struct #packed {
	input_data:            []u8,
	input:                 io.Stream,
	output:                ^bytes.Buffer,
	bytes_written:         i64,
	code_buffer:           u64,
	num_bits:              u64,
	size_packed:           i64,
	size_unpacked:         i64,
	input_fully_in_memory: b8,
	padding:               [1]u8,
}

Deflate_Error :: enum int {
	None                     = 0, 
	Huffman_Bad_Sizes, 
	Huffman_Bad_Code_Lengths, 
	Inflate_Error, 
	Bad_Distance, 
	Bad_Huffman_Code, 
	Len_Nlen_Mismatch, 
	BType_3, 
}

GZIP_Error :: General_Error

ZIP_Error :: enum int {
	None                                     = 0, 
	Invalid_ZIP_File_Signature, 
	Unexpected_Signature, 
	Insert_Next_Disk, 
	Expected_End_of_Central_Directory_Record, 
}

ZLIB_Error :: enum int {
	None                          = 0, 
	Unsupported_Window_Size, 
	FDICT_Unsupported, 
	Unsupported_Compression_Level, 
	Code_Buffer_Malformed, 
}

peek_bits_lsb_from_memory :: Error

peek_bits_lsb_from_stream :: GZIP_Error

COMPRESS_OUTPUT_ALLOCATE_MIN :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MIN, 1 << 20))

discard_to_next_byte_lsb :: COMPRESS_OUTPUT_ALLOCATE_MAX

COMPRESS_OUTPUT_ALLOCATE_MAX :: peek_bits_lsb_from_stream

Context_Memory_Input :: read_slice_from_memory

Context_Stream_Input :: read_data

Error :: refill_lsb_from_memory

consume_bits_lsb_from_memory :: proc(z: ^Context_Memory_Input, width: u8) {…}

consume_bits_lsb_from_stream :: proc(z: ^Context_Stream_Input, width: u8) {…}

discard_to_next_byte_lsb_from_memory :: proc(z: ^Context_Memory_Input) {…}

discard_to_next_byte_lsb_from_stream :: read_bits_lsb_from_memory

input_size_from_memory :: proc(z: ^Context_Memory_Input) -> (res: i64, err: Error) {…}

input_size_from_stream :: peek_bits_lsb_from_memory

peek_back_byte :: proc(z: ^$C, offset: i64) -> (res: u8, err: io.Error) {…}

peek_bits_lsb_from_stream :: discard_to_next_byte_lsb_from_stream

peek_bits_no_refill_lsb_from_memory :: proc(z: ^Context_Memory_Input, width: u8) -> u32 {…}

peek_bits_no_refill_lsb_from_stream :: proc(z: ^Context_Stream_Input, width: u8) -> u32 {…}

peek_data_at_offset_from_memory :: proc(z: ^Context_Memory_Input, $T: typeid, #any_int offset: int) -> (res: typeid, err: io.Error) {…}

peek_data_at_offset_from_stream :: proc(z: ^Context_Stream_Input, $T: typeid, #any_int offset: int) -> (res: typeid, err: io.Error) {…}

peek_data_from_memory :: proc(z: ^Context_Memory_Input, $T: typeid) -> (res: typeid, err: io.Error) {…}

peek_data_from_stream :: proc(z: ^Context_Stream_Input, $T: typeid) -> (res: typeid, err: io.Error) {…}

read_bits_lsb_from_stream :: proc(z: ^Context_Stream_Input, width: u8) -> u32 {…}

read_bits_no_refill_lsb_from_memory :: proc(z: ^Context_Memory_Input, width: u8) -> u32 {…}

read_bits_no_refill_lsb_from_stream :: proc(z: ^Context_Stream_Input, width: u8) -> u32 {…}

read_data :: input_size_from_stream

read_slice_from_stream :: proc(z: ^Context_Stream_Input, size: int) -> (res: []u8, err: io.Error) {…}

read_u8_from_memory :: proc(z: ^Context_Memory_Input) -> (res: u8, err: io.Error) {…}

read_u8_from_stream :: proc(z: ^Context_Stream_Input) -> (res: u8, err: io.Error) {…}

read_u8_prefer_code_buffer_lsb :: proc(z: ^$C) -> (res: u8, err: io.Error) {…}

refill_lsb_from_stream :: proc(z: ^Context_Stream_Input, width: i8 = i8(24)) {…}

consume_bits_lsb :: proc{
	consume_bits_lsb_from_memory,
	consume_bits_lsb_from_stream,
}

discard_to_next_byte_lsb :: proc{
	discard_to_next_byte_lsb_from_memory,
	discard_to_next_byte_lsb_from_stream,
}

input_size :: proc{
	input_size_from_memory,
	input_size_from_stream,
}

peek_bits_lsb :: proc{
	peek_bits_lsb_from_memory,
	peek_bits_lsb_from_stream,
}

peek_bits_no_refill_lsb :: proc{
	peek_bits_no_refill_lsb_from_memory,
	peek_bits_no_refill_lsb_from_stream,
}

peek_data :: proc{
	peek_data_from_memory,
	peek_data_from_stream,
	peek_data_at_offset_from_memory,
	peek_data_at_offset_from_stream,
}

read_bits_lsb :: proc{
	read_bits_lsb_from_memory,
	read_bits_lsb_from_stream,
}

read_bits_no_refill_lsb :: proc{
	read_bits_no_refill_lsb_from_memory,
	read_bits_no_refill_lsb_from_stream,
}

read_slice :: proc{
	read_slice_from_memory,
	read_slice_from_stream,
}

read_u8 :: proc{
	read_u8_from_memory,
	read_u8_from_stream,
}

refill_lsb :: proc{
	refill_lsb_from_memory,
	refill_lsb_from_stream,
}