package core:compress/filters

Source

BCJ2_Error :: compress.BCJ2_Error

Bcj2_Streams :: struct {
	main: [dynamic]u8,
	call: [dynamic]u8,
	jump: [dynamic]u8,
	rc:   [dynamic]u8,
}

Branch_Arch :: enum u8 {
	X86, 
	PowerPC, 
	IA64, 
	ARM, 
	ARM_Thumb, 
	SPARC, 
	ARM64, 
	RISCV, 
}

Branch_State :: struct {
	arch:     Branch_Arch,
	pc:       u32,
	x86_mask: u32,
}

Delta_State :: struct {
	distance: int,
	history:  [256]u8,
}

Error :: compress.Error

General_Error :: compress.General_Error

BCJ2_RELAT_LIMIT_DEFAULT :: u32(0x0F) << 24

BCJ2_RELAT_LIMIT_MAX :: u32(1) << 31

DELTA_DISTANCE_MAX :: 256

DELTA_DISTANCE_MIN :: 1

BRANCH_ALIGNMENT: [Branch_Arch]int = …

bcj2_decode_to_dynamic :: proc(
	output:               ^[dynamic]u8, 
	main, call, jump, rc: []u8, 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

bcj2_decode_to_slice :: proc(
	output:               []u8, 
	main, call, jump, rc: []u8, 
) -> (err: compress.Error) {…}

bcj2_encode :: proc(
	streams:     ^Bcj2_Streams, 
	input:       []u8, 
	relat_limit: u32 = BCJ2_RELAT_LIMIT_DEFAULT, 
	file_size:   i64 = i64(-1), 
	allocator := context.allocator, 
) -> (err: compress.Error) {…}

branch_decode :: proc "contextless" (state: ^Branch_State, data: []u8) -> (processed: int) {…}

branch_encode :: proc "contextless" (state: ^Branch_State, data: []u8) -> (processed: int) {…}

branch_init :: proc "contextless" (
	state:        ^Branch_State, 
	arch:         Branch_Arch, 
	start_offset: u32 = 0, 
) -> bool {…}

delta_decode :: proc "contextless" (state: ^Delta_State, data: []u8) {…}

delta_encode :: proc "contextless" (state: ^Delta_State, data: []u8) {…}

delta_init :: proc "contextless" (state: ^Delta_State, distance: int) -> bool {…}

swap2 :: proc "contextless" (data: []u8) -> (processed: int) {…}

swap4 :: proc "contextless" (data: []u8) -> (processed: int) {…}

bcj2_decode :: proc{
	bcj2_decode_to_slice,
	bcj2_decode_to_dynamic,
}