package core:compress/lzma

Source

Error :: compress.Error

General_Error :: compress.General_Error

LZMA_Error :: compress.LZMA_Error

Level :: enum i32 {
	Level_0 = 0, 
	Level_1 = 1, 
	Level_2 = 2, 
	Level_3 = 3, 
	Level_4 = 4, 
	Level_5 = 5, 
	Level_6 = 6, 
	Level_7 = 7, 
	Level_8 = 8, 
	Level_9 = 9, 
	Fastest = Level_0, 
	Default = Level_6, 
	Best    = Level_9, 
}

Match_Finder_Kind :: enum u8 {
	HC4, 
	HC5, 
	BT2, 
	BT3, 
	BT4, 
	BT5, 
}

Options :: struct {
	lc:           u8,
	lp:           u8,
	pb:           u8,
	dict_size:    u32,
	fast:         bool,
	nice_len:     u32,
	depth:        u32,
	match_finder: Match_Finder_Kind,
	end_marker:   bool,
}

Properties :: struct {
	lc:        u8,
	lp:        u8,
	pb:        u8,
	dict_size: u32,
}

DEFAULT_PROPERTIES :: Properties{lc = 3, lp = 0, pb = 2, dict_size = 8 << 20}

DICT_SIZE_MIN :: 1 << 12

HEADER_SIZE :: PROPERTIES_SIZE + 8

LC_MAX :: 8

LP_MAX :: 4

LZMA2_DICT_PROP_MAX :: 40

LZMA2_LCLP_MAX :: 4

PB_MAX :: 4

PROPERTIES_SIZE :: 5

UNKNOWN_SIZE: u64 : max(u64)

compress_bound :: proc(length: int) -> int {…}

compress_lzma2_bound :: proc(length: int) -> int {…}

compress_lzma2_to_dynamic :: proc(
	output:    ^[dynamic]u8, 
	input:     []u8, 
	options:   Options, 
	allocator := context.allocator, 
) -> (props: Properties, err: compress.Error) {…}

compress_lzma2_to_slice :: proc(
	output, input: []u8, 
	options:       Options, 
	allocator := context.allocator, 
) -> (written: int, props: Properties, err: compress.Error) {…}

compress_raw_to_dynamic :: proc(
	output:    ^[dynamic]u8, 
	input:     []u8, 
	options:   Options, 
	allocator := context.allocator, 
) -> (props: Properties, err: compress.Error) {…}

compress_raw_to_slice :: proc(
	output, input: []u8, 
	options:       Options, 
	allocator := context.allocator, 
) -> (written: int, props: Properties, err: compress.Error) {…}

compress_to_dynamic :: proc(
	output:    ^[dynamic]u8, 
	input:     []u8, 
	level:     Level = Level.Default, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

compress_to_slice :: proc(
	output, input: []u8, 
	level:         Level = Level.Default, 
	allocator := context.allocator, 
) -> (written: int, err: compress.Error) {…}

decode_properties :: proc "contextless" (data: []u8) -> (props: Properties, err: compress.Error) {…}

decompress_from_bytes :: proc(
	output:               ^[dynamic]u8, 
	input:                []u8, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

decompress_from_context :: proc(
	z:                    ^compress.Context, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

decompress_lzma2_from_bytes :: proc(
	output:               ^[dynamic]u8, 
	input:                []u8, 
	dict_size:            u32, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

decompress_lzma2_from_context :: proc(
	z:                    ^compress.Context, 
	dict_size:            u32, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

decompress_raw_from_bytes :: proc(
	output:               ^[dynamic]u8, 
	input:                []u8, 
	props:                Properties, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

decompress_raw_from_context :: proc(
	z:                    ^compress.Context, 
	props:                Properties, 
	expected_output_size: int = -1, 
	max_output_size:      int = compress.COMPRESS_OUTPUT_ALLOCATE_MAX, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

encode_properties :: proc "contextless" (props: Properties) -> (data: [5]u8) {…}

level_options :: proc(level: Level = Level.Default) -> (options: Options) {…}

lzma2_dict_prop :: proc "contextless" (dict_size: u32) -> (prop: u8) {…}

lzma2_dict_size :: proc "contextless" (prop: u8) -> (dict_size: u32, err: compress.Error) {…}

compress :: proc{
	compress_to_slice,
	compress_to_dynamic,
}

compress_lzma2 :: proc{
	compress_lzma2_to_slice,
	compress_lzma2_to_dynamic,
}

compress_raw :: proc{
	compress_raw_to_slice,
	compress_raw_to_dynamic,
}

decompress :: proc{
	decompress_from_bytes,
	decompress_from_context,
}

decompress_lzma2 :: proc{
	decompress_lzma2_from_bytes,
	decompress_lzma2_from_context,
}

decompress_raw :: proc{
	decompress_raw_from_bytes,
	decompress_raw_from_context,
}