From 882b775f7140815d82dd74f1713380debf7a1eaa Mon Sep 17 00:00:00 2001 From: Natalia Portillo Date: Tue, 14 Apr 2026 20:23:16 +0100 Subject: [PATCH] Add LHA, LHARC, LARC and PMARC decompression support for various algorithms - Implemented LZSS compression in lha/lzss.c and lha/lzss.h. - Added PMarc decompression functionality in lha/pmarc1.c and lha/pmarc1.h. - Updated library.h to include declarations for new decompression functions. - Enhanced tests to cover LHA decompression for LH1, LH6, and PMarc formats. - Added test helpers for loading LHA payloads and validating decompression results. - Included sample data files for testing LHA and PMarc decompression. --- CMakeLists.txt | 18 +- lha/bitio.c | 98 +++ lha/bitio.h | 44 ++ lha/huffman.c | 259 ++++++++ lha/huffman.h | 57 ++ lha/larc.c | 134 +++++ lha/larc.h | 30 + lha/lh1.c | 280 +++++++++ lha/lh1.h | 28 + lha/lh_old.c | 1217 ++++++++++++++++++++++++++++++++++++++ lha/lh_old.h | 32 + lha/lh_static.c | 252 ++++++++ lha/lh_static.h | 34 ++ lha/lzss.c | 48 ++ lha/lzss.h | 68 +++ lha/pmarc1.c | 387 ++++++++++++ lha/pmarc1.h | 29 + library.h | 33 ++ tests/CMakeLists.txt | 15 +- tests/data/larc_lz5.lzs | Bin 0 -> 73153 bytes tests/data/lha_lh6.lzh | Bin 0 -> 54239 bytes tests/data/lharc_lh1.lzh | Bin 0 -> 64995 bytes tests/data/pmarc_pm2.pma | Bin 0 -> 60416 bytes tests/lha/larc.cpp | 74 +++ tests/lha/lh1.cpp | 74 +++ tests/lha/lh_old.cpp | 75 +++ tests/lha/lh_static.cpp | 74 +++ tests/lha/lha_helpers.h | 122 ++++ 28 files changed, 3480 insertions(+), 2 deletions(-) create mode 100644 lha/bitio.c create mode 100644 lha/bitio.h create mode 100644 lha/huffman.c create mode 100644 lha/huffman.h create mode 100644 lha/larc.c create mode 100644 lha/larc.h create mode 100644 lha/lh1.c create mode 100644 lha/lh1.h create mode 100644 lha/lh_old.c create mode 100644 lha/lh_old.h create mode 100644 lha/lh_static.c create mode 100644 lha/lh_static.h create mode 100644 lha/lzss.c create mode 100644 lha/lzss.h create mode 100644 lha/pmarc1.c create mode 100644 lha/pmarc1.h create mode 100644 tests/data/larc_lz5.lzs create mode 100644 tests/data/lha_lh6.lzh create mode 100755 tests/data/lharc_lh1.lzh create mode 100755 tests/data/pmarc_pm2.pma create mode 100644 tests/lha/larc.cpp create mode 100644 tests/lha/lh1.cpp create mode 100644 tests/lha/lh_old.cpp create mode 100644 tests/lha/lh_static.cpp create mode 100644 tests/lha/lha_helpers.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2cd2cbc..87ceb68 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -145,7 +145,23 @@ add_library("Aaru.Compression.Native" SHARED library.c apple_rle.c apple_rle.h a ha/hsc.h ha/internal.h ha/swdict.c - ha/swdict.h) + ha/swdict.h + lha/bitio.c + lha/bitio.h + lha/lzss.c + lha/lzss.h + lha/huffman.c + lha/huffman.h + lha/larc.c + lha/larc.h + lha/lh1.c + lha/lh1.h + lha/lh_static.c + lha/lh_static.h + lha/lh_old.c + lha/lh_old.h + lha/pmarc1.c + lha/pmarc1.h) include(3rdparty/bzip2.cmake) include(3rdparty/flac.cmake) diff --git a/lha/bitio.c b/lha/bitio.c new file mode 100644 index 0000000..22cfe7c --- /dev/null +++ b/lha/bitio.c @@ -0,0 +1,98 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "bitio.h" + +#include + +void lha_bitio_init(lha_bitio *self, const uint8_t *buffer, size_t length) +{ + self->buffer = buffer; + self->length = length; + self->pos = 0; + self->bits = 0; + self->numbits = 0; + self->eof = false; +} + +static void lha_bitio_fill(lha_bitio *self) +{ + while(self->numbits <= 24 && self->pos < self->length) + { + self->bits |= (uint32_t)self->buffer[self->pos++] << (24 - self->numbits); + self->numbits += 8; + } + + if(self->pos >= self->length && self->numbits == 0) self->eof = true; +} + +bool lha_bitio_at_eof(lha_bitio *self) { return self->eof && self->numbits == 0; } + +unsigned int lha_bitio_next_bit(lha_bitio *self) +{ + if(self->numbits == 0) lha_bitio_fill(self); + + if(self->numbits == 0) return 0; + + unsigned int bit = (self->bits >> 31) & 1; + self->bits <<= 1; + self->numbits--; + return bit; +} + +unsigned int lha_bitio_next_bits(lha_bitio *self, int numbits) +{ + if(numbits == 0) return 0; + + if((int)self->numbits < numbits) lha_bitio_fill(self); + + unsigned int result = self->bits >> (32 - numbits); + self->bits <<= numbits; + self->numbits -= numbits; + return result; +} + +unsigned int lha_bitio_peek_bits(lha_bitio *self, int numbits) +{ + if(numbits == 0) return 0; + + if((int)self->numbits < numbits) lha_bitio_fill(self); + + return self->bits >> (32 - numbits); +} + +void lha_bitio_skip_bits(lha_bitio *self, int numbits) +{ + self->bits <<= numbits; + self->numbits -= numbits; +} + +int lha_bitio_next_byte(lha_bitio *self) +{ + if(self->pos >= self->length && self->numbits < 8) return -1; + + /* If on byte boundary, read directly */ + if(self->numbits == 0) + { + if(self->pos < self->length) return self->buffer[self->pos++]; + + return -1; + } + + return (int)lha_bitio_next_bits(self, 8); +} diff --git a/lha/bitio.h b/lha/bitio.h new file mode 100644 index 0000000..86c6ad6 --- /dev/null +++ b/lha/bitio.h @@ -0,0 +1,44 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_BITIO_H_ +#define AARU_COMPRESSION_NATIVE__LHA_BITIO_H_ + +#include +#include +#include + +typedef struct lha_bitio +{ + const uint8_t *buffer; + size_t length; + size_t pos; + uint32_t bits; + unsigned int numbits; + bool eof; +} lha_bitio; + +void lha_bitio_init(lha_bitio *self, const uint8_t *buffer, size_t length); +bool lha_bitio_at_eof(lha_bitio *self); +unsigned int lha_bitio_next_bit(lha_bitio *self); +unsigned int lha_bitio_next_bits(lha_bitio *self, int numbits); +unsigned int lha_bitio_peek_bits(lha_bitio *self, int numbits); +void lha_bitio_skip_bits(lha_bitio *self, int numbits); +int lha_bitio_next_byte(lha_bitio *self); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_BITIO_H_ */ diff --git a/lha/huffman.c b/lha/huffman.c new file mode 100644 index 0000000..8d05238 --- /dev/null +++ b/lha/huffman.c @@ -0,0 +1,259 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "huffman.h" + +#include +#include +#include + +/* --- Internal helpers --- */ + +static inline int left_branch(lha_prefix_code *c, int node) { return c->tree[node].branches[0]; } + +static inline int right_branch(lha_prefix_code *c, int node) { return c->tree[node].branches[1]; } + +static inline void set_branch(lha_prefix_code *c, int node, int bit, int next) +{ + c->tree[node].branches[bit] = next; +} + +static inline bool is_leaf(lha_prefix_code *c, int node) +{ + return c->tree[node].branches[0] == c->tree[node].branches[1]; +} + +static inline int leaf_value(lha_prefix_code *c, int node) { return left_branch(c, node); } + +static inline void set_leaf(lha_prefix_code *c, int node, int value) +{ + c->tree[node].branches[0] = value; + c->tree[node].branches[1] = value; +} + +static inline void set_empty(lha_prefix_code *c, int node) +{ + c->tree[node].branches[0] = -1; + c->tree[node].branches[1] = -2; +} + +static inline bool is_empty(lha_prefix_code *c, int node) +{ + return c->tree[node].branches[0] == -1 && c->tree[node].branches[1] == -2; +} + +static inline bool is_open(lha_prefix_code *c, int node, int bit) { return c->tree[node].branches[bit] < 0; } + +static int new_node(lha_prefix_code *c) +{ + lha_tree_node *tmp = (lha_tree_node *)realloc(c->tree, (size_t)(c->numentries + 1) * sizeof(lha_tree_node)); + + if(!tmp) return -1; + + c->tree = tmp; + set_empty(c, c->numentries); + return c->numentries++; +} + +/* --- Build lookup table --- */ + +static void make_table(lha_prefix_code *code, int node, lha_table_entry *table, int depth, int maxdepth) +{ + int currtablesize = 1 << (maxdepth - depth); + + if(node < 0) + { + int i; + for(i = 0; i < currtablesize; i++) table[i].length = (uint32_t)-1; + } + else if(is_leaf(code, node)) + { + int i; + for(i = 0; i < currtablesize; i++) + { + table[i].length = (uint32_t)depth; + table[i].value = leaf_value(code, node); + } + } + else + { + if(depth == maxdepth) + { + table[0].length = (uint32_t)(maxdepth + 1); + table[0].value = node; + } + else + { + make_table(code, left_branch(code, node), table, depth + 1, maxdepth); + make_table(code, right_branch(code, node), table + currtablesize / 2, depth + 1, maxdepth); + } + } +} + +static void build_table(lha_prefix_code *code) +{ + if(code->table) return; + + if(code->maxlength < code->minlength) + code->tablesize = LHA_HUFFMAN_TABLE_SIZE; + else if(code->maxlength >= LHA_HUFFMAN_TABLE_SIZE) + code->tablesize = LHA_HUFFMAN_TABLE_SIZE; + else + code->tablesize = code->maxlength; + + code->table = (lha_table_entry *)malloc(sizeof(lha_table_entry) * (size_t)(1 << code->tablesize)); + + if(code->table) make_table(code, 0, code->table, 0, code->tablesize); +} + +/* --- Public API --- */ + +lha_prefix_code *lha_prefix_code_new(void) +{ + lha_prefix_code *code = (lha_prefix_code *)calloc(1, sizeof(lha_prefix_code)); + + if(!code) return NULL; + + code->tree = (lha_tree_node *)malloc(sizeof(lha_tree_node)); + + if(!code->tree) + { + free(code); + return NULL; + } + + set_empty(code, 0); + code->numentries = 1; + code->minlength = INT_MAX; + code->maxlength = INT_MIN; + code->table = NULL; + code->tablesize = 0; + + return code; +} + +lha_prefix_code *lha_prefix_code_from_lengths(const int *lengths, int num_symbols, int max_length, + bool shortest_is_zeros) +{ + lha_prefix_code *code = lha_prefix_code_new(); + + if(!code) return NULL; + + int codeval = 0; + int symbolsleft = num_symbols; + int length, i; + + for(length = 1; length <= max_length; length++) + { + for(i = 0; i < num_symbols; i++) + { + if(lengths[i] != length) continue; + + if(shortest_is_zeros) + lha_prefix_code_add(code, i, (uint32_t)codeval, length); + else + lha_prefix_code_add(code, i, (uint32_t)~codeval, length); + + codeval++; + + if(--symbolsleft == 0) return code; + } + + codeval <<= 1; + } + + return code; +} + +void lha_prefix_code_free(lha_prefix_code *code) +{ + if(!code) return; + + free(code->tree); + free(code->table); + free(code); +} + +void lha_prefix_code_add(lha_prefix_code *code, int value, uint32_t codebits, int length) +{ + int bitpos, lastnode; + + /* Invalidate lookup table */ + free(code->table); + code->table = NULL; + + if(length > code->maxlength) code->maxlength = length; + if(length < code->minlength) code->minlength = length; + + lastnode = 0; + + for(bitpos = length - 1; bitpos >= 0; bitpos--) + { + int bit = (codebits >> bitpos) & 1; + + if(is_leaf(code, lastnode)) return; /* prefix collision */ + + if(is_open(code, lastnode, bit)) set_branch(code, lastnode, bit, new_node(code)); + + lastnode = code->tree[lastnode].branches[bit]; + + if(lastnode < 0) return; /* allocation failure */ + } + + if(!is_empty(code, lastnode)) return; /* prefix collision */ + + set_leaf(code, lastnode, value); +} + +int lha_prefix_code_decode(lha_bitio *bitio, lha_prefix_code *code) +{ + int bits, length, value, node; + + if(!code) return -1; + + build_table(code); + + if(!code->table) return -1; + + bits = (int)lha_bitio_peek_bits(bitio, code->tablesize); + length = (int)code->table[bits].length; + value = code->table[bits].value; + + if(length == (int)(uint32_t)-1) return -1; /* invalid code */ + + if(length <= code->tablesize) + { + lha_bitio_skip_bits(bitio, length); + return value; + } + + lha_bitio_skip_bits(bitio, code->tablesize); + + node = value; + + while(!is_leaf(code, node)) + { + int bit = (int)lha_bitio_next_bit(bitio); + + if(is_open(code, node, bit)) return -1; + + node = code->tree[node].branches[bit]; + } + + return leaf_value(code, node); +} diff --git a/lha/huffman.h b/lha/huffman.h new file mode 100644 index 0000000..c4f3a3e --- /dev/null +++ b/lha/huffman.h @@ -0,0 +1,57 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_HUFFMAN_H_ +#define AARU_COMPRESSION_NATIVE__LHA_HUFFMAN_H_ + +#include +#include +#include "bitio.h" + +#define LHA_HUFFMAN_TABLE_SIZE 10 + +typedef struct +{ + int branches[2]; +} lha_tree_node; + +typedef struct +{ + uint32_t length; + int32_t value; +} lha_table_entry; + +typedef struct lha_prefix_code +{ + lha_tree_node *tree; + int numentries; + int minlength; + int maxlength; + + int tablesize; + lha_table_entry *table; +} lha_prefix_code; + +lha_prefix_code *lha_prefix_code_new(void); +lha_prefix_code *lha_prefix_code_from_lengths(const int *lengths, int num_symbols, int max_length, + bool shortest_is_zeros); +void lha_prefix_code_free(lha_prefix_code *code); +void lha_prefix_code_add(lha_prefix_code *code, int value, uint32_t codebits, int length); +int lha_prefix_code_decode(lha_bitio *bitio, lha_prefix_code *code); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_HUFFMAN_H_ */ diff --git a/lha/larc.c b/lha/larc.c new file mode 100644 index 0000000..1573905 --- /dev/null +++ b/lha/larc.c @@ -0,0 +1,134 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "larc.h" +#include "bitio.h" +#include "lzss.h" + +#include + +/* + * LArc -lzs- decompression. + * Window: 2048 bytes. + * Bit stream, MSB first. + * Flag bit 1 = literal (8 bits), flag bit 0 = match (11-bit offset + 4-bit length). + */ +AARU_EXPORT int AARU_CALL larc_decompress_lzs(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lha_bitio bitio; + lha_lzss lzss; + size_t expected; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + + if(!lha_lzss_init(&lzss, 2048, out_buf, expected)) return -1; + + lha_bitio_init(&bitio, in_buf, in_len); + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + if(lha_bitio_next_bit(&bitio)) + { + /* Literal byte */ + uint8_t literal = (uint8_t)lha_bitio_next_bits(&bitio, 8); + lha_lzss_emit_literal(&lzss, literal); + } + else + { + /* Match */ + int raw_offset = (int)lha_bitio_next_bits(&bitio, 11); + int length = (int)lha_bitio_next_bits(&bitio, 4) + 2; + int offset = (int)lzss.position - raw_offset - 17; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + + *out_len = lzss.out_pos; + lha_lzss_cleanup(&lzss); + return 0; +} + +/* + * LArc -lz5- decompression. + * Window: 4096 bytes, pre-filled with specific byte pattern. + * Flag-byte stream: each flag byte controls 8 items. + * Flag bit set = literal (1 byte), flag bit clear = match (2 bytes). + */ +AARU_EXPORT int AARU_CALL larc_decompress_lz5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lha_lzss lzss; + size_t expected; + size_t in_pos; + int i; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + + if(!lha_lzss_init(&lzss, 4096, out_buf, expected)) return -1; + + /* Pre-fill window with specific pattern (same as lharc -lh1-) */ + for(i = 0; i < 256; i++) memset(&lzss.window[i * 13 + 18], i, 13); + + for(i = 0; i < 256; i++) lzss.window[256 * 13 + 18 + i] = (uint8_t)i; + + for(i = 0; i < 256; i++) lzss.window[256 * 13 + 256 + 18 + i] = (uint8_t)(255 - i); + + memset(&lzss.window[256 * 13 + 512 + 18], 0, 128); + memset(&lzss.window[256 * 13 + 512 + 128 + 18], ' ', 128 - 18); + + in_pos = 0; + + while(lzss.out_pos < expected && in_pos < in_len) + { + uint8_t flags = in_buf[in_pos++]; + int bit; + + for(bit = 0; bit < 8 && lzss.out_pos < expected && in_pos < in_len; bit++) + { + if(flags & (1 << bit)) + { + /* Literal */ + lha_lzss_emit_literal(&lzss, in_buf[in_pos++]); + } + else + { + /* Match: 2 bytes */ + uint8_t byte1, byte2; + int offset, length; + + if(in_pos + 1 >= in_len) break; + + byte1 = in_buf[in_pos++]; + byte2 = in_buf[in_pos++]; + + offset = (int)lzss.position - (int)byte1 - ((byte2 & 0xf0) << 4) - 18; + length = (byte2 & 0x0f) + 3; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + } + + *out_len = lzss.out_pos; + lha_lzss_cleanup(&lzss); + return 0; +} diff --git a/lha/larc.h b/lha/larc.h new file mode 100644 index 0000000..54af3e5 --- /dev/null +++ b/lha/larc.h @@ -0,0 +1,30 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_LARC_H_ +#define AARU_COMPRESSION_NATIVE__LHA_LARC_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL larc_decompress_lzs(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL larc_decompress_lz5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_LARC_H_ */ diff --git a/lha/lh1.c b/lha/lh1.c new file mode 100644 index 0000000..f5305a9 --- /dev/null +++ b/lha/lh1.c @@ -0,0 +1,280 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "lh1.h" +#include "bitio.h" +#include "huffman.h" +#include "lzss.h" + +#include + +#define LH1_NUM_LEAVES 314 +#define LH1_NUM_NODES (LH1_NUM_LEAVES * 2 - 1) + +typedef struct lh1_node +{ + struct lh1_node *parent; + struct lh1_node *leftchild; + struct lh1_node *rightchild; + int index; /* Position in sorted nodes[] array */ + int freq; + int value; /* Symbol value for leaf nodes */ +} lh1_node; + +typedef struct +{ + lh1_node storage[LH1_NUM_NODES]; + lh1_node *nodes[LH1_NUM_NODES]; /* Sorted by frequency order */ +} lh1_tree; + +static void lh1_init_tree(lh1_tree *tree) +{ + int i; + + memset(tree->storage, 0, sizeof(tree->storage)); + + for(i = 0; i < LH1_NUM_NODES; i++) tree->nodes[i] = &tree->storage[i]; + + /* Initialize leaf nodes (at the high end of the sorted array) */ + for(i = 0; i < LH1_NUM_LEAVES; i++) + { + int index = LH1_NUM_NODES - 1 - i; + tree->nodes[index]->index = index; + tree->nodes[index]->freq = 1; + tree->nodes[index]->value = i; + tree->nodes[index]->leftchild = NULL; + tree->nodes[index]->rightchild = NULL; + } + + /* Build branch nodes bottom-up */ + for(i = LH1_NUM_LEAVES - 2; i >= 0; i--) + { + tree->nodes[i]->index = i; + tree->nodes[i]->leftchild = tree->nodes[2 * i + 1]; + tree->nodes[i]->rightchild = tree->nodes[2 * i + 2]; + tree->nodes[i]->leftchild->parent = tree->nodes[i]; + tree->nodes[i]->rightchild->parent = tree->nodes[i]; + tree->nodes[i]->freq = tree->nodes[i]->leftchild->freq + tree->nodes[i]->rightchild->freq; + } + + tree->nodes[0]->parent = NULL; +} + +static void lh1_rearrange(lh1_tree *tree, lh1_node *node) +{ + int p_index = node->index; + int q_index = p_index; + lh1_node *p = node; + lh1_node *q; + + /* Find highest position where this node should be */ + while(q_index > 0 && tree->nodes[q_index - 1]->freq < p->freq) q_index--; + + if(q_index >= p_index) return; + + q = tree->nodes[q_index]; + + /* Swap parent-child links using pointers */ + { + lh1_node *new_q_parent = p->parent; + lh1_node *new_p_parent = q->parent; + int p_is_right = (p->parent && p->parent->rightchild == p); + int q_is_right = (q->parent && q->parent->rightchild == q); + + if(p->parent) + { + if(p_is_right) + p->parent->rightchild = q; + else + p->parent->leftchild = q; + } + + if(q->parent) + { + if(q_is_right) + q->parent->rightchild = p; + else + q->parent->leftchild = p; + } + + p->parent = new_p_parent; + q->parent = new_q_parent; + } + + /* Swap positions in sorted array */ + tree->nodes[p_index] = q; + tree->nodes[p_index]->index = p_index; + tree->nodes[q_index] = p; + tree->nodes[q_index]->index = q_index; +} + +static void lh1_reconstruct(lh1_tree *tree) +{ + lh1_node *leaves[LH1_NUM_LEAVES]; + int n = 0; + int i; + int leaf_index, branch_index, node_index, pair_index; + + /* Collect all leaf nodes and halve their frequencies */ + for(i = 0; i < LH1_NUM_NODES; i++) + { + if(!tree->nodes[i]->leftchild && !tree->nodes[i]->rightchild) + { + tree->nodes[i]->freq = (tree->nodes[i]->freq + 1) / 2; + leaves[n++] = tree->nodes[i]; + } + } + + leaf_index = LH1_NUM_LEAVES - 1; + branch_index = LH1_NUM_LEAVES - 2; + node_index = LH1_NUM_NODES - 1; + pair_index = LH1_NUM_NODES - 2; + + while(node_index >= 0) + { + while(node_index >= pair_index) + { + tree->nodes[node_index] = leaves[leaf_index]; + tree->nodes[node_index]->index = node_index; + node_index--; + leaf_index--; + } + + { + lh1_node *branch = &tree->storage[branch_index--]; + branch->leftchild = tree->nodes[pair_index]; + branch->rightchild = tree->nodes[pair_index + 1]; + branch->leftchild->parent = branch; + branch->rightchild->parent = branch; + branch->freq = tree->nodes[pair_index]->freq + tree->nodes[pair_index + 1]->freq; + + while(leaf_index >= 0 && leaves[leaf_index]->freq <= branch->freq) + { + tree->nodes[node_index] = leaves[leaf_index]; + tree->nodes[node_index]->index = node_index; + node_index--; + leaf_index--; + } + + tree->nodes[node_index] = branch; + tree->nodes[node_index]->index = node_index; + node_index--; + pair_index -= 2; + } + } + + tree->nodes[0]->parent = NULL; +} + +static void lh1_update(lh1_tree *tree, lh1_node *node) +{ + if(tree->nodes[0]->freq == 0x8000) lh1_reconstruct(tree); + + for(;;) + { + node->freq++; + + if(!node->parent) break; + + lh1_rearrange(tree, node); + node = node->parent; + } +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lha_bitio bitio; + lha_lzss lzss; + lh1_tree tree; + lha_prefix_code *distancecode; + size_t expected; + int i; + + static const int dist_lengths[64] = {3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + + if(!lha_lzss_init(&lzss, 4096, out_buf, expected)) return -1; + + /* Pre-fill window with specific pattern */ + for(i = 0; i < 256; i++) memset(&lzss.window[i * 13 + 18], i, 13); + + for(i = 0; i < 256; i++) lzss.window[256 * 13 + 18 + i] = (uint8_t)i; + + for(i = 0; i < 256; i++) lzss.window[256 * 13 + 256 + 18 + i] = (uint8_t)(255 - i); + + memset(&lzss.window[256 * 13 + 512 + 18], 0, 128); + memset(&lzss.window[256 * 13 + 512 + 128 + 18], ' ', 128 - 18); + + distancecode = lha_prefix_code_from_lengths(dist_lengths, 64, 8, true); + + if(!distancecode) + { + lha_lzss_cleanup(&lzss); + return -1; + } + + lha_bitio_init(&bitio, in_buf, in_len); + lh1_init_tree(&tree); + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + /* Traverse adaptive Huffman tree */ + lh1_node *node = tree.nodes[0]; /* root */ + + while(node->leftchild || node->rightchild) + { + if(lha_bitio_next_bit(&bitio)) + node = node->leftchild; + else + node = node->rightchild; + + if(!node) break; + } + + if(!node) break; + + lh1_update(&tree, node); + + if(node->value < 0x100) + { + /* Literal */ + lha_lzss_emit_literal(&lzss, (uint8_t)node->value); + } + else + { + /* Match */ + int length = node->value - 0x100 + 3; + int highbits = lha_prefix_code_decode(&bitio, distancecode); + int lowbits = (int)lha_bitio_next_bits(&bitio, 6); + int offset = (highbits << 6) + lowbits + 1; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + + *out_len = lzss.out_pos; + lha_prefix_code_free(distancecode); + lha_lzss_cleanup(&lzss); + return 0; +} diff --git a/lha/lh1.h b/lha/lh1.h new file mode 100644 index 0000000..59b2149 --- /dev/null +++ b/lha/lh1.h @@ -0,0 +1,28 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_LH1_H_ +#define AARU_COMPRESSION_NATIVE__LHA_LH1_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL lha_decompress_lh1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_LH1_H_ */ diff --git a/lha/lh_old.c b/lha/lh_old.c new file mode 100644 index 0000000..091ba6e --- /dev/null +++ b/lha/lh_old.c @@ -0,0 +1,1217 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +/* + * Self-contained port of LH2, LH3 and PM2 decompression from legacy code. + * Uses its own 16-bit bit I/O and Huffman tree management. + */ + +#include "lh_old.h" + +#include +#include + +/* --- Constants --- */ + +#define UCHAR_MAX_VAL 255 +#define CHAR_BIT_VAL 8 +#define USHRT_BIT 16 +#define MAXMATCH 256 +#define NC (UCHAR_MAX_VAL + MAXMATCH + 2 - THRESHOLD) +#define THRESHOLD 3 +#define NPT 0x80 +#define CBIT 9 +#define TBIT 5 +#define NT (USHRT_BIT + 3) +#define N_CHAR (256 + 60 - THRESHOLD + 1) +#define TREESIZE_C (N_CHAR * 2) +#define TREESIZE_P (128 * 2) +#define TREESIZE (TREESIZE_C + TREESIZE_P) +#define ROOT_C 0 +#define ROOT_P TREESIZE_C +#define N1 286 +#define EXTRABITS 8 +#define BUFBITS 16 +#define NP (MAX_DICBIT + 1) +#define MAX_DICBIT 16 +#define LENFIELD 4 +#define PMARC2_OFFSET (0x100 - 2) + +/* --- Buffer I/O --- */ + +typedef struct +{ + const uint8_t *in_buf; + size_t in_len; + size_t in_pos; + uint8_t *out_buf; + size_t out_len; + size_t out_pos; + int error; +} lhold_io; + +static int lhold_getchar(lhold_io *io) +{ + if(io->in_pos >= io->in_len) return 0; + + return io->in_buf[io->in_pos++]; +} + +static void lhold_putchar(lhold_io *io, uint8_t c) +{ + if(io->out_pos < io->out_len) io->out_buf[io->out_pos++] = c; +} + +static int lhold_at_end(lhold_io *io) { return io->out_pos >= io->out_len; } + +/* --- PM2 Tree --- */ + +struct pmarc2_tree +{ + uint8_t *leftarr; + uint8_t *rightarr; + uint8_t root; +}; + +/* --- Decompression data --- */ + +struct lhold_st +{ + int32_t pbit; + int32_t np; + int32_t nn; + int32_t n1; + int32_t most_p; + int32_t avail; + uint32_t n_max; + uint16_t maxmatch; + uint16_t total_p; + uint16_t blocksize; + uint16_t c_table[4096]; + uint16_t pt_table[256]; + uint16_t left[2 * NC - 1]; + uint16_t right[2 * NC - 1]; + uint16_t freq[TREESIZE]; + uint16_t pt_code[NPT]; + int16_t child[TREESIZE]; + int16_t stock[TREESIZE]; + int16_t s_node[TREESIZE / 2]; + int16_t block[TREESIZE]; + int16_t parent[TREESIZE]; + int16_t edge[TREESIZE]; + uint8_t c_len[NC]; + uint8_t pt_len[NPT]; +}; + +struct lhold_pm +{ + struct pmarc2_tree tree1; + struct pmarc2_tree tree2; + uint16_t lastupdate; + uint16_t dicsiz1; + uint8_t gettree1; + uint8_t tree1left[32]; + uint8_t tree1right[32]; + uint8_t table1[32]; + uint8_t tree2left[8]; + uint8_t tree2right[8]; + uint8_t table2[8]; + uint8_t tree1bound; + uint8_t mindepth; + uint8_t prev[0x100]; + uint8_t next[0x100]; + uint8_t parentarr[0x100]; + uint8_t lastbyte; +}; + +struct lhold_data +{ + lhold_io *io; + uint8_t *text; + uint16_t dicbit; + + uint16_t bitbuf; + uint8_t subbitbuf; + uint8_t bitcount; + uint32_t loc; + uint32_t count; + uint32_t nextcount; + + union + { + struct lhold_st st; + struct lhold_pm pm; + } d; +}; + +/* --- Bit I/O (16-bit accumulator) --- */ + +static void fillbuf(struct lhold_data *dat, uint8_t n) +{ + if(dat->io->error) return; + + while(n > dat->bitcount) + { + n -= dat->bitcount; + dat->bitbuf = (uint16_t)((dat->bitbuf << dat->bitcount) + (dat->subbitbuf >> (CHAR_BIT_VAL - dat->bitcount))); + dat->subbitbuf = (uint8_t)lhold_getchar(dat->io); + dat->bitcount = CHAR_BIT_VAL; + } + + dat->bitcount -= n; + dat->bitbuf = (uint16_t)((dat->bitbuf << n) + (dat->subbitbuf >> (CHAR_BIT_VAL - n))); + dat->subbitbuf <<= n; +} + +static uint16_t getbits(struct lhold_data *dat, uint8_t n) +{ + uint16_t x = (uint16_t)(dat->bitbuf >> (2 * CHAR_BIT_VAL - n)); + + fillbuf(dat, n); + return x; +} + +#define init_getbits(a) fillbuf((a), 2 * CHAR_BIT_VAL) + +/* --- Huffman table construction --- */ + +static void make_table(struct lhold_data *dat, int16_t nchar, uint8_t bitlen[], int16_t tablebits, uint16_t table[]) +{ + uint16_t count[17]; + uint16_t weight[17]; + uint16_t start[17]; + uint16_t total; + uint32_t i; + int32_t j, k, l, m, n, avail; + uint16_t *p; + + if(dat->io->error) return; + + avail = nchar; + memset(count, 0, sizeof(count)); + + for(i = 1; i <= 16; i++) weight[i] = (uint16_t)(1 << (16 - i)); + + for(i = 0; (int32_t)i < nchar; i++) count[bitlen[i]]++; + + total = 0; + + for(i = 1; i <= 16; i++) + { + start[i] = total; + total = (uint16_t)(total + weight[i] * count[i]); + } + + if(total & 0xFFFF) + { + dat->io->error = 1; + return; + } + + m = 16 - tablebits; + + for(i = 1; (int32_t)i <= tablebits; i++) + { + start[i] >>= m; + weight[i] >>= m; + } + + j = start[tablebits + 1] >> m; + k = 1 << tablebits; + + if(j != 0) + for(i = (uint32_t)j; (int32_t)i < k; i++) table[i] = 0; + + for(j = 0; j < nchar; j++) + { + k = bitlen[j]; + + if(k == 0) continue; + + l = start[k] + weight[k]; + + if(k <= tablebits) + { + for(i = (uint32_t)start[k]; (int32_t)i < l; i++) table[i] = (uint16_t)j; + } + else + { + p = &table[(i = (uint32_t)start[k]) >> m]; + i <<= tablebits; + n = k - tablebits; + + while(--n >= 0) + { + if(*p == 0) + { + dat->d.st.right[avail] = dat->d.st.left[avail] = 0; + *p = (uint16_t)avail++; + } + + if(i & 0x8000) + p = &dat->d.st.right[*p]; + else + p = &dat->d.st.left[*p]; + + i <<= 1; + } + + *p = (uint16_t)j; + } + + start[k] = (uint16_t)l; + } +} + +/* --- LH2: Dynamic Huffman --- */ + +static void start_p_dyn(struct lhold_data *dat) +{ + dat->d.st.freq[ROOT_P] = 1; + dat->d.st.child[ROOT_P] = (int16_t)(~(N_CHAR)); + dat->d.st.s_node[N_CHAR] = ROOT_P; + dat->d.st.edge[dat->d.st.block[ROOT_P] = dat->d.st.stock[dat->d.st.avail++]] = ROOT_P; + dat->d.st.most_p = ROOT_P; + dat->d.st.total_p = 0; + dat->d.st.nn = 1 << dat->dicbit; + dat->nextcount = 64; +} + +static void start_c_dyn(struct lhold_data *dat) +{ + int32_t i, j, f; + + dat->d.st.n1 = (int32_t)((dat->d.st.n_max >= (uint32_t)(256 + dat->d.st.maxmatch - THRESHOLD + 1)) ? 512 + : dat->d.st.n_max - 1); + + for(i = 0; i < TREESIZE_C; i++) + { + dat->d.st.stock[i] = (int16_t)i; + dat->d.st.block[i] = 0; + } + + for(i = 0, j = (int32_t)(dat->d.st.n_max * 2 - 2); i < (int32_t)dat->d.st.n_max; i++, j--) + { + dat->d.st.freq[j] = 1; + dat->d.st.child[j] = (int16_t)(~i); + dat->d.st.s_node[i] = (int16_t)j; + dat->d.st.block[j] = 1; + } + + dat->d.st.avail = 2; + dat->d.st.edge[1] = (int16_t)(dat->d.st.n_max - 1); + i = (int32_t)(dat->d.st.n_max * 2 - 2); + + while(j >= 0) + { + f = dat->d.st.freq[j] = dat->d.st.freq[i] + dat->d.st.freq[i - 1]; + dat->d.st.child[j] = (int16_t)i; + dat->d.st.parent[i] = dat->d.st.parent[i - 1] = (int16_t)j; + + if(f == dat->d.st.freq[j + 1]) + dat->d.st.edge[dat->d.st.block[j] = dat->d.st.block[j + 1]] = (int16_t)j; + else + dat->d.st.edge[dat->d.st.block[j] = dat->d.st.stock[dat->d.st.avail++]] = (int16_t)j; + + i -= 2; + j--; + } +} + +static void decode_start_dyn(struct lhold_data *dat) +{ + dat->d.st.n_max = 286; + dat->d.st.maxmatch = MAXMATCH; + init_getbits(dat); + start_c_dyn(dat); + start_p_dyn(dat); +} + +static void reconst(struct lhold_data *dat, int32_t start, int32_t end) +{ + int32_t i, j, k, l, b = 0; + uint32_t f, g; + + for(i = j = start; i < end; i++) + { + if((k = dat->d.st.child[i]) < 0) + { + dat->d.st.freq[j] = (uint16_t)((dat->d.st.freq[i] + 1) / 2); + dat->d.st.child[j] = (int16_t)k; + j++; + } + + if(dat->d.st.edge[b = dat->d.st.block[i]] == i) dat->d.st.stock[--dat->d.st.avail] = (int16_t)b; + } + + j--; + i = end - 1; + l = end - 2; + + while(i >= start) + { + while(i >= l) + { + dat->d.st.freq[i] = dat->d.st.freq[j]; + dat->d.st.child[i] = dat->d.st.child[j]; + i--; + j--; + } + + f = (uint32_t)(dat->d.st.freq[l] + dat->d.st.freq[l + 1]); + + for(k = start; f < (uint32_t)dat->d.st.freq[k]; k++) + ; + + while(j >= k) + { + dat->d.st.freq[i] = dat->d.st.freq[j]; + dat->d.st.child[i] = dat->d.st.child[j]; + i--; + j--; + } + + dat->d.st.freq[i] = (uint16_t)f; + dat->d.st.child[i] = (int16_t)(l + 1); + i--; + l -= 2; + } + + f = 0; + + for(i = start; i < end; i++) + { + if((j = dat->d.st.child[i]) < 0) + dat->d.st.s_node[~j] = (int16_t)i; + else + dat->d.st.parent[j] = dat->d.st.parent[j - 1] = (int16_t)i; + + if((g = (uint32_t)dat->d.st.freq[i]) == f) + dat->d.st.block[i] = (int16_t)b; + else + { + dat->d.st.edge[b = dat->d.st.block[i] = dat->d.st.stock[dat->d.st.avail++]] = (int16_t)i; + f = g; + } + } +} + +static int32_t swap_inc(struct lhold_data *dat, int32_t p) +{ + int32_t b, q, r, s; + + b = dat->d.st.block[p]; + + if((q = dat->d.st.edge[b]) != p) + { + r = dat->d.st.child[p]; + s = dat->d.st.child[q]; + dat->d.st.child[p] = (int16_t)s; + dat->d.st.child[q] = (int16_t)r; + + if(r >= 0) + dat->d.st.parent[r] = dat->d.st.parent[r - 1] = (int16_t)q; + else + dat->d.st.s_node[~r] = (int16_t)q; + + if(s >= 0) + dat->d.st.parent[s] = dat->d.st.parent[s - 1] = (int16_t)p; + else + dat->d.st.s_node[~s] = (int16_t)p; + + p = q; + dat->d.st.edge[b]++; + + if(++dat->d.st.freq[p] == dat->d.st.freq[p - 1]) + dat->d.st.block[p] = dat->d.st.block[p - 1]; + else + dat->d.st.edge[dat->d.st.block[p] = dat->d.st.stock[dat->d.st.avail++]] = (int16_t)p; + } + else if(b == dat->d.st.block[p + 1]) + { + dat->d.st.edge[b]++; + + if(++dat->d.st.freq[p] == dat->d.st.freq[p - 1]) + dat->d.st.block[p] = dat->d.st.block[p - 1]; + else + dat->d.st.edge[dat->d.st.block[p] = dat->d.st.stock[dat->d.st.avail++]] = (int16_t)p; + } + else if(++dat->d.st.freq[p] == dat->d.st.freq[p - 1]) + { + dat->d.st.stock[--dat->d.st.avail] = (int16_t)b; + dat->d.st.block[p] = dat->d.st.block[p - 1]; + } + + return dat->d.st.parent[p]; +} + +static void update_p(struct lhold_data *dat, int32_t p) +{ + int32_t q; + + if(dat->d.st.total_p == 0x8000) + { + reconst(dat, ROOT_P, dat->d.st.most_p + 1); + dat->d.st.total_p = dat->d.st.freq[ROOT_P]; + dat->d.st.freq[ROOT_P] = 0xffff; + } + + q = dat->d.st.s_node[p + N_CHAR]; + + while(q != ROOT_P) q = swap_inc(dat, q); + + dat->d.st.total_p++; +} + +static void make_new_node(struct lhold_data *dat, int32_t p) +{ + int32_t q, r; + + r = dat->d.st.most_p + 1; + q = r + 1; + dat->d.st.s_node[~(dat->d.st.child[r] = dat->d.st.child[dat->d.st.most_p])] = (int16_t)r; + dat->d.st.child[q] = (int16_t)(~(p + N_CHAR)); + dat->d.st.child[dat->d.st.most_p] = (int16_t)q; + dat->d.st.freq[r] = dat->d.st.freq[dat->d.st.most_p]; + dat->d.st.freq[q] = 0; + dat->d.st.block[r] = dat->d.st.block[dat->d.st.most_p]; + + if(dat->d.st.most_p == ROOT_P) + { + dat->d.st.freq[ROOT_P] = 0xffff; + dat->d.st.edge[dat->d.st.block[ROOT_P]]++; + } + + dat->d.st.parent[r] = dat->d.st.parent[q] = (int16_t)dat->d.st.most_p; + dat->d.st.edge[dat->d.st.block[q] = dat->d.st.stock[dat->d.st.avail++]] = dat->d.st.s_node[p + N_CHAR] = + (int16_t)(dat->d.st.most_p = q); + update_p(dat, p); +} + +static void update_c(struct lhold_data *dat, int32_t p) +{ + int32_t q; + + if(dat->d.st.freq[ROOT_C] == 0x8000) reconst(dat, 0, (int32_t)dat->d.st.n_max * 2 - 1); + + dat->d.st.freq[ROOT_C]++; + q = dat->d.st.s_node[p]; + + do { q = swap_inc(dat, q); } while(q != ROOT_C); +} + +static uint16_t decode_c_dyn(struct lhold_data *dat) +{ + int32_t c; + int16_t buf, cnt; + + c = dat->d.st.child[ROOT_C]; + buf = (int16_t)dat->bitbuf; + cnt = 0; + + do + { + c = dat->d.st.child[c - (buf < 0)]; + buf <<= 1; + + if(++cnt == 16) + { + fillbuf(dat, 16); + buf = (int16_t)dat->bitbuf; + cnt = 0; + } + } while(c > 0); + + fillbuf(dat, (uint8_t)cnt); + c = ~c; + update_c(dat, c); + + if(c == dat->d.st.n1) c += getbits(dat, 8); + + return (uint16_t)c; +} + +static uint16_t decode_p_dyn(struct lhold_data *dat) +{ + int32_t c; + int16_t buf, cnt; + + while(dat->count > dat->nextcount) + { + make_new_node(dat, (int32_t)dat->nextcount / 64); + + if((dat->nextcount += 64) >= (uint32_t)dat->d.st.nn) dat->nextcount = 0xffffffff; + } + + c = dat->d.st.child[ROOT_P]; + buf = (int16_t)dat->bitbuf; + cnt = 0; + + while(c > 0) + { + c = dat->d.st.child[c - (buf < 0)]; + buf <<= 1; + + if(++cnt == 16) + { + fillbuf(dat, 16); + buf = (int16_t)dat->bitbuf; + cnt = 0; + } + } + + fillbuf(dat, (uint8_t)cnt); + c = (~c) - N_CHAR; + update_p(dat, c); + + return (uint16_t)((c << 6) + getbits(dat, 6)); +} + +/* --- LH3: Static Huffman --- */ + +static const int32_t fixed_tables[2][16] = {{3, 0x01, 0x04, 0x0c, 0x18, 0x30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {2, 0x01, 0x01, 0x03, 0x06, 0x0D, 0x1F, 0x4E, 0, 0, 0, 0, 0, 0, 0, 0}}; + +static void ready_made(struct lhold_data *dat, int32_t method) +{ + int32_t i, j; + uint32_t code, weight_val; + const int32_t *tbl; + + tbl = fixed_tables[method]; + j = *tbl++; + weight_val = (uint32_t)(1 << (16 - j)); + code = 0; + + for(i = 0; i < dat->d.st.np; i++) + { + while(*tbl == i) + { + j++; + tbl++; + weight_val >>= 1; + } + + dat->d.st.pt_len[i] = (uint8_t)j; + dat->d.st.pt_code[i] = (uint16_t)code; + code += weight_val; + } +} + +static uint16_t decode_p_st0(struct lhold_data *dat) +{ + int32_t i, j; + + j = dat->d.st.pt_table[dat->bitbuf >> 8]; + + if(j < dat->d.st.np) + { + fillbuf(dat, dat->d.st.pt_len[j]); + } + else + { + fillbuf(dat, 8); + i = dat->bitbuf; + + do + { + if((int16_t)i < 0) + j = dat->d.st.right[j]; + else + j = dat->d.st.left[j]; + + i <<= 1; + } while(j >= dat->d.st.np); + + fillbuf(dat, (uint8_t)(dat->d.st.pt_len[j] - 8)); + } + + return (uint16_t)((j << 6) + getbits(dat, 6)); +} + +static void decode_start_st0(struct lhold_data *dat) +{ + dat->d.st.n_max = 286; + dat->d.st.maxmatch = MAXMATCH; + init_getbits(dat); + dat->d.st.np = 1 << (MAX_DICBIT - 6); +} + +static void read_tree_c(struct lhold_data *dat) +{ + int32_t i, c; + + i = 0; + + while(i < N1) + { + if(getbits(dat, 1)) + dat->d.st.c_len[i] = (uint8_t)(getbits(dat, LENFIELD) + 1); + else + dat->d.st.c_len[i] = 0; + + if(++i == 3 && dat->d.st.c_len[0] == 1 && dat->d.st.c_len[1] == 1 && dat->d.st.c_len[2] == 1) + { + c = getbits(dat, CBIT); + memset(dat->d.st.c_len, 0, N1); + + for(i = 0; i < 4096; i++) dat->d.st.c_table[i] = (uint16_t)c; + + return; + } + } + + make_table(dat, N1, dat->d.st.c_len, 12, dat->d.st.c_table); +} + +static void read_tree_p(struct lhold_data *dat) +{ + int32_t i, c; + + i = 0; + + while(i < NP) + { + dat->d.st.pt_len[i] = (uint8_t)getbits(dat, LENFIELD); + + if(++i == 3 && dat->d.st.pt_len[0] == 1 && dat->d.st.pt_len[1] == 1 && dat->d.st.pt_len[2] == 1) + { + c = getbits(dat, MAX_DICBIT - 6); + + for(i = 0; i < NP; i++) dat->d.st.c_len[i] = 0; + + for(i = 0; i < 256; i++) dat->d.st.c_table[i] = (uint16_t)c; + + return; + } + } +} + +static uint16_t decode_c_st0(struct lhold_data *dat) +{ + int32_t i, j; + + if(!dat->d.st.blocksize) + { + dat->d.st.blocksize = getbits(dat, BUFBITS); + read_tree_c(dat); + + if(getbits(dat, 1)) + read_tree_p(dat); + else + ready_made(dat, 1); + + make_table(dat, NP, dat->d.st.pt_len, 8, dat->d.st.pt_table); + } + + dat->d.st.blocksize--; + j = dat->d.st.c_table[dat->bitbuf >> 4]; + + if(j < N1) + { + fillbuf(dat, dat->d.st.c_len[j]); + } + else + { + fillbuf(dat, 12); + i = dat->bitbuf; + + do + { + if((int16_t)i < 0) + j = dat->d.st.right[j]; + else + j = dat->d.st.left[j]; + + i <<= 1; + } while(j >= N1); + + fillbuf(dat, (uint8_t)(dat->d.st.c_len[j] - 12)); + } + + if(j == N1 - 1) j += getbits(dat, EXTRABITS); + + return (uint16_t)j; +} + +/* --- PM2: PMarc v2 --- */ + +static const int32_t pmarc2_historyBits[8] = {3, 3, 4, 5, 5, 5, 6, 6}; +static const int32_t pmarc2_historyBase[8] = {0, 8, 16, 32, 64, 96, 128, 192}; +static const int32_t pmarc2_repeatBits[6] = {3, 3, 5, 6, 7, 0}; +static const int32_t pmarc2_repeatBase[6] = {17, 25, 33, 65, 129, 256}; + +static void pmarc2_hist_update(struct lhold_data *dat, uint8_t data) +{ + if(data != dat->d.pm.lastbyte) + { + uint8_t oldNext, oldPrev, newNext; + + oldNext = dat->d.pm.next[data]; + oldPrev = dat->d.pm.prev[data]; + dat->d.pm.prev[oldNext] = oldPrev; + dat->d.pm.next[oldPrev] = oldNext; + + newNext = dat->d.pm.next[dat->d.pm.lastbyte]; + dat->d.pm.prev[newNext] = data; + dat->d.pm.next[data] = newNext; + + dat->d.pm.prev[data] = dat->d.pm.lastbyte; + dat->d.pm.next[dat->d.pm.lastbyte] = data; + + dat->d.pm.lastbyte = data; + } +} + +static int32_t pmarc2_tree_get(struct lhold_data *dat, struct pmarc2_tree *t) +{ + int32_t i = t->root; + + while(i < 0x80) i = (getbits(dat, 1) == 0 ? t->leftarr[i] : t->rightarr[i]); + + return i & 0x7F; +} + +static void pmarc2_tree_rebuild(struct lhold_data *dat, struct pmarc2_tree *t, uint8_t bound, uint8_t mindepth, + uint8_t *table) +{ + uint8_t d; + int32_t i, curr, empty_node, n; + + t->root = 0; + memset(t->leftarr, 0, bound); + memset(t->rightarr, 0, bound); + memset(dat->d.pm.parentarr, 0, bound); + + for(i = 0; i < dat->d.pm.mindepth - 1; i++) + { + t->leftarr[i] = (uint8_t)(i + 1); + dat->d.pm.parentarr[i + 1] = (uint8_t)i; + } + + curr = dat->d.pm.mindepth - 1; + empty_node = dat->d.pm.mindepth; + + for(d = dat->d.pm.mindepth;; d++) + { + for(i = 0; i < bound; i++) + { + if(table[i] == d) + { + if(t->leftarr[curr] == 0) + { + t->leftarr[curr] = (uint8_t)(i | 128); + } + else + { + t->rightarr[curr] = (uint8_t)(i | 128); + n = 0; + + while(t->rightarr[curr] != 0) + { + if(curr == 0) return; + + curr = dat->d.pm.parentarr[curr]; + n++; + } + + t->rightarr[curr] = (uint8_t)empty_node; + + for(;;) + { + dat->d.pm.parentarr[empty_node] = (uint8_t)curr; + curr = empty_node; + empty_node++; + n--; + + if(n == 0) break; + + t->leftarr[curr] = (uint8_t)empty_node; + } + } + } + } + + if(t->leftarr[curr] == 0) + t->leftarr[curr] = (uint8_t)empty_node; + else + t->rightarr[curr] = (uint8_t)empty_node; + + dat->d.pm.parentarr[empty_node] = (uint8_t)curr; + curr = empty_node; + empty_node++; + } +} + +static uint8_t pmarc2_hist_lookup(struct lhold_data *dat, int32_t n) +{ + uint8_t i; + uint8_t *direction = dat->d.pm.prev; + + if(n >= 0x80) + { + direction = dat->d.pm.next; + n = 0x100 - n; + } + + for(i = dat->d.pm.lastbyte; n != 0; n--) i = direction[i]; + + return i; +} + +static void pmarc2_maketree1(struct lhold_data *dat) +{ + int32_t i, nbits, x; + + dat->d.pm.tree1bound = (uint8_t)getbits(dat, 5); + dat->d.pm.mindepth = (uint8_t)getbits(dat, 3); + + if(dat->d.pm.mindepth == 0) + { + dat->d.pm.tree1.root = (uint8_t)(128 | (dat->d.pm.tree1bound - 1)); + } + else + { + memset(dat->d.pm.table1, 0, 32); + nbits = getbits(dat, 3); + + for(i = 0; i < dat->d.pm.tree1bound; i++) + { + if((x = getbits(dat, (uint8_t)nbits))) dat->d.pm.table1[i] = (uint8_t)(x - 1 + dat->d.pm.mindepth); + } + + pmarc2_tree_rebuild(dat, &dat->d.pm.tree1, dat->d.pm.tree1bound, dat->d.pm.mindepth, dat->d.pm.table1); + } +} + +static void pmarc2_maketree2(struct lhold_data *dat, int32_t par_b) +{ + int32_t i, count, index; + + if(dat->d.pm.tree1bound < 10) return; + + if(dat->d.pm.tree1bound == 29 && dat->d.pm.mindepth == 0) return; + + for(i = 0; i < 8; i++) dat->d.pm.table2[i] = 0; + + for(i = 0; i < par_b; i++) dat->d.pm.table2[i] = (uint8_t)getbits(dat, 3); + + index = 0; + count = 0; + + for(i = 0; i < 8; i++) + { + if(dat->d.pm.table2[i] != 0) + { + index = i; + count++; + } + } + + if(count == 1) + dat->d.pm.tree2.root = (uint8_t)(128 | index); + else if(count > 1) + { + dat->d.pm.mindepth = 1; + pmarc2_tree_rebuild(dat, &dat->d.pm.tree2, 8, dat->d.pm.mindepth, dat->d.pm.table2); + } +} + +static void decode_start_pm2(struct lhold_data *dat) +{ + int32_t i; + + dat->d.pm.tree1.leftarr = dat->d.pm.tree1left; + dat->d.pm.tree1.rightarr = dat->d.pm.tree1right; + dat->d.pm.tree2.leftarr = dat->d.pm.tree2left; + dat->d.pm.tree2.rightarr = dat->d.pm.tree2right; + + dat->d.pm.dicsiz1 = (uint16_t)((1 << dat->dicbit) - 1); + init_getbits(dat); + + /* Initialize history list */ + for(i = 0; i < 0x100; i++) + { + dat->d.pm.prev[(0xFF + i) & 0xFF] = (uint8_t)i; + dat->d.pm.next[(0x01 + i) & 0xFF] = (uint8_t)i; + } + + dat->d.pm.prev[0x7F] = 0x00; + dat->d.pm.next[0x00] = 0x7F; + dat->d.pm.prev[0xDF] = 0x80; + dat->d.pm.next[0x80] = 0xDF; + dat->d.pm.prev[0x9F] = 0xE0; + dat->d.pm.next[0xE0] = 0x9F; + dat->d.pm.prev[0x1F] = 0xA0; + dat->d.pm.next[0xA0] = 0x1F; + dat->d.pm.prev[0xFF] = 0x20; + dat->d.pm.next[0x20] = 0xFF; + dat->d.pm.lastbyte = 0x20; + + getbits(dat, 1); /* discard bit */ +} + +static uint16_t decode_c_pm2(struct lhold_data *dat) +{ + while(dat->d.pm.lastupdate != dat->loc) + { + pmarc2_hist_update(dat, dat->text[dat->d.pm.lastupdate]); + dat->d.pm.lastupdate = (uint16_t)((dat->d.pm.lastupdate + 1) & dat->d.pm.dicsiz1); + } + + while(dat->count >= dat->nextcount) + { + if(dat->nextcount == 0x0000) + { + pmarc2_maketree1(dat); + pmarc2_maketree2(dat, 5); + dat->nextcount = 0x0400; + } + else if(dat->nextcount == 0x0400) + { + pmarc2_maketree2(dat, 6); + dat->nextcount = 0x0800; + } + else if(dat->nextcount == 0x0800) + { + pmarc2_maketree2(dat, 7); + dat->nextcount = 0x1000; + } + else if(dat->nextcount == 0x1000) + { + if(getbits(dat, 1) != 0) pmarc2_maketree1(dat); + + pmarc2_maketree2(dat, 8); + dat->nextcount = 0x2000; + } + else + { + if(getbits(dat, 1) != 0) + { + pmarc2_maketree1(dat); + pmarc2_maketree2(dat, 8); + } + + dat->nextcount += 0x1000; + } + } + + dat->d.pm.gettree1 = (uint8_t)pmarc2_tree_get(dat, &dat->d.pm.tree1); + + if(dat->d.pm.gettree1 < 8) + return (uint16_t)(pmarc2_hist_lookup(dat, + pmarc2_historyBase[dat->d.pm.gettree1] + + getbits(dat, (uint8_t)pmarc2_historyBits[dat->d.pm.gettree1]))); + + if(dat->d.pm.gettree1 < 23) return (uint16_t)(PMARC2_OFFSET + 2 + (dat->d.pm.gettree1 - 8)); + + return (uint16_t)(PMARC2_OFFSET + pmarc2_repeatBase[dat->d.pm.gettree1 - 23] + + getbits(dat, (uint8_t)pmarc2_repeatBits[dat->d.pm.gettree1 - 23])); +} + +static uint16_t decode_p_pm2(struct lhold_data *dat) +{ + int32_t nbits, delta, gettree2; + + if(dat->d.pm.gettree1 == 8) + { + nbits = 6; + delta = 0; + } + else if(dat->d.pm.gettree1 < 28) + { + if(!(gettree2 = pmarc2_tree_get(dat, &dat->d.pm.tree2))) + { + nbits = 6; + delta = 0; + } + else + { + nbits = 5 + gettree2; + delta = 1 << nbits; + } + } + else + { + nbits = 0; + delta = 0; + } + + return (uint16_t)(delta + getbits(dat, (uint8_t)nbits)); +} + +/* --- Main decompression dispatcher --- */ + +#define METHOD_LH2 0 +#define METHOD_LH3 1 +#define METHOD_PM2 2 + +static int lhold_decrunch(lhold_io *io, int method) +{ + struct lhold_data *dd; + int result = -1; + + dd = (struct lhold_data *)calloc(1, sizeof(struct lhold_data)); + + if(!dd) return -1; + + dd->io = io; + dd->dicbit = 13; + + { + void (*decodeStart)(struct lhold_data *) = NULL; + uint16_t (*decodeC)(struct lhold_data *) = NULL; + uint16_t (*decodeP)(struct lhold_data *) = NULL; + + switch(method) + { + case METHOD_LH2: + decodeStart = decode_start_dyn; + decodeC = decode_c_dyn; + decodeP = decode_p_dyn; + break; + case METHOD_LH3: + decodeStart = decode_start_st0; + decodeP = decode_p_st0; + decodeC = decode_c_st0; + break; + case METHOD_PM2: + decodeStart = decode_start_pm2; + decodeP = decode_p_pm2; + decodeC = decode_c_pm2; + break; + default: free(dd); return -1; + } + + { + uint32_t dicsiz = (uint32_t)(1 << dd->dicbit); + int32_t offset = (method == METHOD_PM2) ? 0x100 - 2 : 0x100 - 3; + + dd->text = (uint8_t *)calloc(dicsiz, 1); + + if(!dd->text) + { + free(dd); + return -1; + } + + memset(dd->text, ' ', dicsiz); + + decodeStart(dd); + dicsiz--; /* now used with AND */ + + while(!lhold_at_end(io) && !io->error) + { + int32_t c = decodeC(dd); + + if(io->error) break; + + if(c <= UCHAR_MAX_VAL) + { + dd->text[dd->loc++] = (uint8_t)c; + lhold_putchar(io, (uint8_t)c); + dd->loc &= dicsiz; + dd->count++; + } + else + { + int32_t i; + uint16_t p; + + c -= offset; + p = decodeP(dd); + + if(io->error) break; + + i = (int32_t)(dd->loc - p - 1); + dd->count += (uint32_t)c; + + while(c--) + { + uint8_t byte = dd->text[i++ & dicsiz]; + dd->text[dd->loc++] = byte; + lhold_putchar(io, byte); + dd->loc &= dicsiz; + } + } + } + + result = io->error ? -1 : 0; + free(dd->text); + } + } + + free(dd); + return result; +} + +/* --- Public API --- */ + +AARU_EXPORT int AARU_CALL lha_decompress_lh2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lhold_io io; + int result; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + memset(&io, 0, sizeof(io)); + io.in_buf = in_buf; + io.in_len = in_len; + io.out_buf = out_buf; + io.out_len = *out_len; + + result = lhold_decrunch(&io, METHOD_LH2); + *out_len = io.out_pos; + return result; +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lhold_io io; + int result; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + memset(&io, 0, sizeof(io)); + io.in_buf = in_buf; + io.in_len = in_len; + io.out_buf = out_buf; + io.out_len = *out_len; + + result = lhold_decrunch(&io, METHOD_LH3); + *out_len = io.out_pos; + return result; +} + +AARU_EXPORT int AARU_CALL pmarc_decompress_pm2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + lhold_io io; + int result; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + memset(&io, 0, sizeof(io)); + io.in_buf = in_buf; + io.in_len = in_len; + io.out_buf = out_buf; + io.out_len = *out_len; + + result = lhold_decrunch(&io, METHOD_PM2); + *out_len = io.out_pos; + return result; +} diff --git a/lha/lh_old.h b/lha/lh_old.h new file mode 100644 index 0000000..ad9a867 --- /dev/null +++ b/lha/lh_old.h @@ -0,0 +1,32 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_LH_OLD_H_ +#define AARU_COMPRESSION_NATIVE__LHA_LH_OLD_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL lha_decompress_lh2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL lha_decompress_lh3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL pmarc_decompress_pm2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_LH_OLD_H_ */ diff --git a/lha/lh_static.c b/lha/lh_static.c new file mode 100644 index 0000000..21b8eda --- /dev/null +++ b/lha/lh_static.c @@ -0,0 +1,252 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "lh_static.h" +#include "bitio.h" +#include "huffman.h" +#include "lzss.h" + +#include +#include + +/* + * Parse a generic Huffman code from the bitstream. + * Width = number of bits for the symbol count. + * specialindex = index at which to insert extra zero-run bits (-1 for none). + */ +static lha_prefix_code *parse_code(lha_bitio *bitio, int width, int specialindex) +{ + int num = (int)lha_bitio_next_bits(bitio, width); + + if(num == 0) + { + /* Single symbol */ + int val = (int)lha_bitio_next_bits(bitio, width); + lha_prefix_code *code = lha_prefix_code_new(); + + if(!code) return NULL; + + lha_prefix_code_add(code, val, 0, 0); + return code; + } + else + { + int *codelengths = (int *)calloc((size_t)num, sizeof(int)); + int n = 0; + lha_prefix_code *code; + + if(!codelengths) return NULL; + + while(n < num) + { + int len = (int)lha_bitio_next_bits(bitio, 3); + + if(len == 7) + while(lha_bitio_next_bit(bitio)) len++; + + codelengths[n++] = len; + + if(n == specialindex) + { + int zeroes = (int)lha_bitio_next_bits(bitio, 2); + int i; + + for(i = 0; i < zeroes && n < num; i++) codelengths[n++] = 0; + } + } + + code = lha_prefix_code_from_lengths(codelengths, num, 16, true); + free(codelengths); + return code; + } +} + +/* + * Parse the literal Huffman code from the bitstream (uses metacode). + */ +static lha_prefix_code *parse_literal_code(lha_bitio *bitio) +{ + lha_prefix_code *metacode = parse_code(bitio, 5, 3); + lha_prefix_code *code; + int num, n; + int *codelengths; + + if(!metacode) return NULL; + + num = (int)lha_bitio_next_bits(bitio, 9); + + if(num == 0) + { + int val = (int)lha_bitio_next_bits(bitio, 9); + + lha_prefix_code_free(metacode); + code = lha_prefix_code_new(); + + if(!code) return NULL; + + lha_prefix_code_add(code, val, 0, 0); + return code; + } + + codelengths = (int *)calloc((size_t)num, sizeof(int)); + + if(!codelengths) + { + lha_prefix_code_free(metacode); + return NULL; + } + + n = 0; + + while(n < num) + { + int c = lha_prefix_code_decode(bitio, metacode); + + if(c < 0) break; + + if(c <= 2) + { + int zeros = 0, i; + + switch(c) + { + case 0: zeros = 1; break; + case 1: zeros = (int)lha_bitio_next_bits(bitio, 4) + 3; break; + case 2: zeros = (int)lha_bitio_next_bits(bitio, 9) + 20; break; + } + + if(n + zeros > num) zeros = num - n; + + for(i = 0; i < zeros; i++) codelengths[n++] = 0; + } + else + { + codelengths[n++] = c - 2; + } + } + + lha_prefix_code_free(metacode); + code = lha_prefix_code_from_lengths(codelengths, num, 16, true); + free(codelengths); + return code; +} + +/* + * Internal decompression for LH4/5/6/7 with parameterized window bits. + */ +static int lh_static_decompress(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len, + int window_bits) +{ + lha_bitio bitio; + lha_lzss lzss; + lha_prefix_code *literalcode = NULL; + lha_prefix_code *distancecode = NULL; + int blocksize = 0; + int blockpos = 0; + size_t expected; + int dist_width; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + dist_width = window_bits < 15 ? 4 : 5; + + if(!lha_lzss_init(&lzss, (size_t)1 << window_bits, out_buf, expected)) return -1; + + lha_bitio_init(&bitio, in_buf, in_len); + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + if(blockpos >= blocksize) + { + /* New block */ + blocksize = (int)lha_bitio_next_bits(&bitio, 16); + blockpos = 0; + + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + + literalcode = parse_literal_code(&bitio); + distancecode = parse_code(&bitio, dist_width, -1); + + if(!literalcode || !distancecode) + { + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + lha_lzss_cleanup(&lzss); + return -1; + } + } + + blockpos++; + + { + int lit = lha_prefix_code_decode(&bitio, literalcode); + + if(lit < 0) break; + + if(lit < 0x100) + { + lha_lzss_emit_literal(&lzss, (uint8_t)lit); + } + else + { + int length = lit - 0x100 + 3; + int bit = lha_prefix_code_decode(&bitio, distancecode); + int offset; + + if(bit < 0) break; + + if(bit == 0) + offset = 1; + else if(bit == 1) + offset = 2; + else + offset = (1 << (bit - 1)) + (int)lha_bitio_next_bits(&bitio, bit - 1) + 1; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + } + + *out_len = lzss.out_pos; + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + lha_lzss_cleanup(&lzss); + return 0; +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh4(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + return lh_static_decompress(in_buf, in_len, out_buf, out_len, 12); +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + return lh_static_decompress(in_buf, in_len, out_buf, out_len, 13); +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh6(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + return lh_static_decompress(in_buf, in_len, out_buf, out_len, 15); +} + +AARU_EXPORT int AARU_CALL lha_decompress_lh7(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len) +{ + return lh_static_decompress(in_buf, in_len, out_buf, out_len, 16); +} diff --git a/lha/lh_static.h b/lha/lh_static.h new file mode 100644 index 0000000..ac8d727 --- /dev/null +++ b/lha/lh_static.h @@ -0,0 +1,34 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_LH_STATIC_H_ +#define AARU_COMPRESSION_NATIVE__LHA_LH_STATIC_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL lha_decompress_lh4(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL lha_decompress_lh5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL lha_decompress_lh6(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +AARU_EXPORT int AARU_CALL lha_decompress_lh7(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_LH_STATIC_H_ */ diff --git a/lha/lzss.c b/lha/lzss.c new file mode 100644 index 0000000..5023bc9 --- /dev/null +++ b/lha/lzss.c @@ -0,0 +1,48 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "lzss.h" + +#include +#include + +bool lha_lzss_init(lha_lzss *self, size_t window_size, uint8_t *out_buf, size_t out_size) +{ + self->window = (uint8_t *)malloc(window_size); + + if(!self->window) return false; + + self->mask = window_size - 1; /* Assume power-of-two */ + self->position = 0; + self->out_buf = out_buf; + self->out_pos = 0; + self->out_size = out_size; + + memset(self->window, 0, window_size); + + return true; +} + +void lha_lzss_cleanup(lha_lzss *self) +{ + if(self->window) + { + free(self->window); + self->window = NULL; + } +} diff --git a/lha/lzss.h b/lha/lzss.h new file mode 100644 index 0000000..0161cf5 --- /dev/null +++ b/lha/lzss.h @@ -0,0 +1,68 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_LZSS_H_ +#define AARU_COMPRESSION_NATIVE__LHA_LZSS_H_ + +#include +#include +#include + +typedef struct lha_lzss +{ + uint8_t *window; + size_t mask; + int64_t position; + uint8_t *out_buf; + size_t out_pos; + size_t out_size; +} lha_lzss; + +bool lha_lzss_init(lha_lzss *self, size_t window_size, uint8_t *out_buf, size_t out_size); +void lha_lzss_cleanup(lha_lzss *self); + +static inline void lha_lzss_emit_literal(lha_lzss *self, uint8_t literal) +{ + self->window[self->position & self->mask] = literal; + self->position++; + + if(self->out_pos < self->out_size) self->out_buf[self->out_pos++] = literal; +} + +static inline void lha_lzss_emit_match(lha_lzss *self, int offset, int length) +{ + size_t windowoffs = (size_t)(self->position & self->mask); + int i; + + for(i = 0; i < length; i++) + { + uint8_t byte = self->window[(windowoffs + i - offset) & self->mask]; + self->window[(windowoffs + i) & self->mask] = byte; + + if(self->out_pos < self->out_size) self->out_buf[self->out_pos++] = byte; + } + + self->position += length; +} + +static inline uint8_t lha_lzss_get_byte(lha_lzss *self, int64_t pos) +{ + return self->window[pos & self->mask]; +} + +#endif /* AARU_COMPRESSION_NATIVE__LHA_LZSS_H_ */ diff --git a/lha/pmarc1.c b/lha/pmarc1.c new file mode 100644 index 0000000..8ca352c --- /dev/null +++ b/lha/pmarc1.c @@ -0,0 +1,387 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * Based on code by Simon Howard, ISC license: + * Copyright (c) 2011, 2012, Simon Howard + * Permission to use, copy, modify, and/or distribute this software + * for any purpose with or without fee is hereby granted, provided + * that the above copyright notice and this permission notice appear + * in all copies. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "pmarc1.h" +#include "bitio.h" +#include "lzss.h" + +#include +#include + +#define MAX_BYTE_BLOCK_LEN 216 + +typedef struct +{ + uint8_t prev; + uint8_t next; +} pma1_history_node; + +typedef struct +{ + pma1_history_node history[256]; + uint8_t history_head; +} pma1_history_list; + +typedef struct +{ + unsigned int offset; + unsigned int bits; +} variable_length_table; + +/* --- History list --- */ + +static void init_history_list(pma1_history_list *list) +{ + int i; + + for(i = 0; i < 256; i++) + { + list->history[i].prev = (uint8_t)(i + 1); + list->history[i].next = (uint8_t)(i - 1); + } + + list->history_head = 0x20; + + list->history[0x7f].prev = 0x00; + list->history[0x00].next = 0x7f; + list->history[0x1f].prev = 0xa0; + list->history[0xa0].next = 0x1f; + list->history[0xdf].prev = 0x80; + list->history[0x80].next = 0xdf; + list->history[0x9f].prev = 0xe0; + list->history[0xe0].next = 0x9f; + list->history[0xff].prev = 0x20; + list->history[0x20].next = 0xff; +} + +static uint8_t find_in_history_list(pma1_history_list *list, uint8_t count) +{ + uint8_t code = list->history_head; + int i; + + if(count < 128) + { + for(i = 0; i < count; i++) code = list->history[code].prev; + } + else + { + for(i = 0; i < 256 - count; i++) code = list->history[code].next; + } + + return code; +} + +static void update_history_list(pma1_history_list *list, uint8_t b) +{ + pma1_history_node *node, *old_head; + + if(list->history_head == b) return; + + node = &list->history[b]; + old_head = &list->history[list->history_head]; + + /* Unhook from current position */ + list->history[node->next].prev = node->prev; + list->history[node->prev].next = node->next; + + /* Hook between old head and its next */ + node->prev = list->history_head; + node->next = old_head->next; + list->history[old_head->next].prev = b; + old_head->next = b; + + list->history_head = b; +} + +/* --- Variable length tables --- */ + +static const variable_length_table copy_ranges[] = { + {0, 6}, /* 0: 0 + (1<<6) = 64 */ + {64, 8}, /* 1: 64 + (1<<8) = 320 */ + {0, 6}, /* 2: 0 + (1<<6) = 64 */ + {64, 9}, /* 3: 64 + (1<<9) = 576 */ + {576, 11}, /* 4: 576 + (1<<11) = 2624 */ + {2624, 13}, /* 5: 2624 + (1<<13) = 10816 */ + /* Early-stream overrides: */ + {64, 8}, /* 6: replaces 3 when pos < 320 */ + {576, 8}, /* 7: replaces 4 when pos < 832 */ + {576, 9}, /* 8: replaces 4 when pos < 1088 */ + {576, 10}, /* 9: replaces 4 when pos < 1600 */ + {2624, 8}, /* 10: replaces 5 when pos < 2880 */ + {2624, 9}, /* 11: replaces 5 when pos < 3136 */ + {2624, 10}, /* 12: replaces 5 when pos < 3648 */ + {2624, 11}, /* 13: replaces 5 when pos < 4672 */ + {2624, 12}, /* 14: replaces 5 when pos < 6720 */ +}; + +static const variable_length_table byte_ranges[] = { + {0, 4}, /* 0 + (1<<4) = 16 */ + {16, 4}, /* 16 + (1<<4) = 32 */ + {32, 5}, /* 32 + (1<<5) = 64 */ + {64, 6}, /* 64 + (1<<6) = 128 */ + {128, 6}, /* 128 + (1<<6) = 192 */ + {192, 6}, /* 192 + (1<<6) = 256 */ +}; + +static const uint8_t byte_decode_trees[][5] = { + {0x12, 0x2d, 0xef, 0x1c, 0xab}, {0x12, 0x23, 0xde, 0xab, 0xcf}, {0x12, 0x2c, 0xd2, 0xab, 0xef}, + {0x12, 0xa2, 0xd2, 0xbc, 0xef}, {0x12, 0xa2, 0xc2, 0xbd, 0xef}, {0x12, 0xa2, 0xcd, 0xb1, 0xef}, + {0x12, 0xab, 0x12, 0xcd, 0xef}, {0x12, 0xab, 0x1d, 0xc1, 0xef}, {0x12, 0xab, 0xc1, 0xd1, 0xef}, + {0xa1, 0x12, 0x2c, 0xde, 0xbf}, {0xa1, 0x1d, 0x1c, 0xb1, 0xef}, {0xa1, 0x12, 0x2d, 0xef, 0xbc}, + {0xa1, 0x12, 0xb2, 0xde, 0xcf}, {0xa1, 0x12, 0xbc, 0xd1, 0xef}, {0xa1, 0x1c, 0xb1, 0xd1, 0xef}, + {0xa1, 0xb1, 0x12, 0xcd, 0xef}, {0xa1, 0xb1, 0xc1, 0xd1, 0xef}, {0x12, 0x1c, 0xde, 0xab, 0x00}, + {0x12, 0xa2, 0xcd, 0xbe, 0x00}, {0x12, 0xab, 0xc1, 0xde, 0x00}, {0xa1, 0x1d, 0x1c, 0xbe, 0x00}, + {0xa1, 0x12, 0xbc, 0xde, 0x00}, {0xa1, 0x1c, 0xb1, 0xde, 0x00}, {0xa1, 0xb1, 0xc1, 0xde, 0x00}, + {0x1d, 0x1c, 0xab, 0x00, 0x00}, {0x1c, 0xa1, 0xbd, 0x00, 0x00}, {0x12, 0xab, 0xcd, 0x00, 0x00}, + {0xa1, 0x1c, 0xbd, 0x00, 0x00}, {0xa1, 0xb1, 0xcd, 0x00, 0x00}, {0xa1, 0xbc, 0x00, 0x00, 0x00}, + {0xab, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00}, +}; + +/* --- Decode helper functions --- */ + +static int decode_variable_length(lha_bitio *input, const variable_length_table *table, unsigned int header) +{ + int value = (int)lha_bitio_next_bits(input, (int)table[header].bits); + + return (int)table[header].offset + value; +} + +static int next_bit_after_threshold(lha_bitio *input, unsigned int pos, unsigned int threshold, int def) +{ + if(pos >= threshold) return (int)lha_bitio_next_bit(input); + + return def; +} + +static int read_copy_byte_count(lha_bitio *input) +{ + int x = (int)lha_bitio_next_bits(input, 2); + + if(x < 3) return x + 3; + + x = (int)lha_bitio_next_bits(input, 3); + + if(x < 5) return x + 6; + else if(x == 5) return (int)lha_bitio_next_bits(input, 2) + 11; + else if(x == 6) return (int)lha_bitio_next_bits(input, 3) + 15; + + /* x == 7 */ + x = (int)lha_bitio_next_bits(input, 6); + + if(x < 62) return x + 23; + else if(x == 62) return (int)lha_bitio_next_bits(input, 5) + 85; + + /* x == 63 */ + return (int)lha_bitio_next_bits(input, 7) + 117; +} + +static int read_copy_type_range(lha_bitio *input, unsigned int pos) +{ + int x = (int)lha_bitio_next_bit(input); + + if(x == 0) + { + x = next_bit_after_threshold(input, pos, 576, 0); + + if(x != 0) return 4; + + return next_bit_after_threshold(input, pos, 64, 0); + } + else + { + x = next_bit_after_threshold(input, pos, 64, 1); + + if(x == 0) return 3; + + x = next_bit_after_threshold(input, pos, 2624, 1); + + if(x != 0) return 2; + + return 5; + } +} + +static int read_byte_decode_index(lha_bitio *input, const uint8_t *tree) +{ + const uint8_t *ptr = tree; + + if(ptr[0] == 0) return 0; + + for(;;) + { + int bit = (int)lha_bitio_next_bit(input); + unsigned int child; + + if(bit == 0) + child = (*ptr >> 4) & 0x0f; + else + child = *ptr & 0x0f; + + if(child >= 10) return (int)(child - 10); + + ptr += child; + } +} + +static int read_byte(lha_bitio *input, const uint8_t *tree, pma1_history_list *history) +{ + int index = read_byte_decode_index(input, tree); + int count = decode_variable_length(input, byte_ranges, (unsigned int)index); + + return find_in_history_list(history, (uint8_t)count); +} + +static int read_byte_block_count(lha_bitio *input) +{ + int x = (int)lha_bitio_next_bits(input, 2); + + if(x < 3) return x + 1; + + x = (int)lha_bitio_next_bits(input, 3); + + if(x < 7) return x + 4; + + x = (int)lha_bitio_next_bits(input, 4); + + if(x < 14) return x + 11; + else if(x == 14) return (int)lha_bitio_next_bits(input, 6) + 25; + + /* x == 15 */ + return (int)lha_bitio_next_bits(input, 7) + 89; +} + +/* --- Main decompression --- */ + +AARU_EXPORT int AARU_CALL pmarc_decompress_pm1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ + lha_bitio bitio; + lha_lzss lzss; + pma1_history_list history; + const uint8_t *byte_tree; + size_t expected; + int bytes_left = 0; + bool next_is_match = false; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + + if(!lha_lzss_init(&lzss, 16384, out_buf, expected)) return -1; + + lha_bitio_init(&bitio, in_buf, in_len); + init_history_list(&history); + + /* Read 5-bit header selecting the byte decode tree */ + { + int index = (int)lha_bitio_next_bits(&bitio, 5); + byte_tree = byte_decode_trees[index]; + } + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + if(bytes_left > 0) + { + /* Emit a byte from the history-encoded stream */ + uint8_t b = (uint8_t)read_byte(&bitio, byte_tree, &history); + lha_lzss_emit_literal(&lzss, b); + update_history_list(&history, b); + bytes_left--; + } + else if(next_is_match || lha_bitio_next_bit(&bitio) == 0) + { + /* Match/copy */ + int range_index, count, history_distance, offset; + + next_is_match = false; + range_index = read_copy_type_range(&bitio, (unsigned int)lzss.position); + + if(range_index < 2) + count = 2; + else + count = read_copy_byte_count(&bitio); + + /* Apply early-stream overrides */ + if(range_index == 3) + { + if(lzss.position < 320) range_index = 6; + } + else if(range_index == 4) + { + if(lzss.position < 832) + range_index = 7; + else if(lzss.position < 1088) + range_index = 8; + else if(lzss.position < 1600) + range_index = 9; + } + else if(range_index == 5) + { + if(lzss.position < 2880) + range_index = 10; + else if(lzss.position < 3136) + range_index = 11; + else if(lzss.position < 3648) + range_index = 12; + else if(lzss.position < 4672) + range_index = 13; + else if(lzss.position < 6720) + range_index = 14; + } + + history_distance = decode_variable_length(&bitio, copy_ranges, (unsigned int)range_index); + offset = history_distance + 1; + + lha_lzss_emit_match(&lzss, offset, count); + + /* Update history for all emitted match bytes */ + { + size_t match_start = lzss.out_pos - (size_t)count; + int i; + + for(i = 0; i < count; i++) update_history_list(&history, out_buf[match_start + i]); + } + } + else + { + /* Byte block: read count, then emit that many literal bytes */ + bytes_left = read_byte_block_count(&bitio); + + if(bytes_left < MAX_BYTE_BLOCK_LEN) next_is_match = true; + + /* Process first byte immediately */ + { + uint8_t b = (uint8_t)read_byte(&bitio, byte_tree, &history); + lha_lzss_emit_literal(&lzss, b); + update_history_list(&history, b); + bytes_left--; + } + } + } + + *out_len = lzss.out_pos; + lha_lzss_cleanup(&lzss); + return 0; +} diff --git a/lha/pmarc1.h b/lha/pmarc1.h new file mode 100644 index 0000000..dca902e --- /dev/null +++ b/lha/pmarc1.h @@ -0,0 +1,29 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__LHA_PMARC1_H_ +#define AARU_COMPRESSION_NATIVE__LHA_PMARC1_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL pmarc_decompress_pm1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__LHA_PMARC1_H_ */ diff --git a/library.h b/library.h index eed194a..caeead9 100644 --- a/library.h +++ b/library.h @@ -201,4 +201,37 @@ AARU_EXPORT int AARU_CALL ha_asc_decompress(const unsigned char *in_buf, size_t AARU_EXPORT int AARU_CALL ha_hsc_decompress(const unsigned char *in_buf, size_t in_len, unsigned char *out_buf, size_t *out_len); +// LHA -lh1- (Dynamic Huffman, 4KB window) +AARU_EXPORT int AARU_CALL lha_decompress_lh1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh2- (Dynamic Huffman, legacy) +AARU_EXPORT int AARU_CALL lha_decompress_lh2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh3- (Static Huffman, legacy) +AARU_EXPORT int AARU_CALL lha_decompress_lh3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh4- (Block Huffman, 4KB window) +AARU_EXPORT int AARU_CALL lha_decompress_lh4(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh5- (Block Huffman, 8KB window) +AARU_EXPORT int AARU_CALL lha_decompress_lh5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh6- (Block Huffman, 32KB window) +AARU_EXPORT int AARU_CALL lha_decompress_lh6(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LHA -lh7- (Block Huffman, 64KB window) +AARU_EXPORT int AARU_CALL lha_decompress_lh7(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LArc -lzs- (LZSS, 2KB window) +AARU_EXPORT int AARU_CALL larc_decompress_lzs(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// LArc -lz5- (Flag-byte LZSS, 4KB window) +AARU_EXPORT int AARU_CALL larc_decompress_lz5(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// PMarc -pm1- (Adaptive history + Huffman) +AARU_EXPORT int AARU_CALL pmarc_decompress_pm1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// PMarc -pm2- (Dynamic trees + history, legacy) +AARU_EXPORT int AARU_CALL pmarc_decompress_pm2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + #endif // AARU_COMPRESSION_NATIVE_LIBRARY_H diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index dca949b..6919daf 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -78,9 +78,22 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/ha_hsc.bin file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/xz.xz DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/larc_lz5.lzs + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/lha_lh6.lzh + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/lharc_lh1.lzh + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/pmarc_pm2.pma + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + # 'Google_Tests_run' is the target name # 'test1.cpp tests2.cpp' are source files with tests add_executable(tests_run apple_rle.cpp crc32.c crc32.h adc.cpp bzip2.cpp lzip.cpp lzfse.cpp zstd.cpp lzma.cpp flac.cpp lz4.cpp zoo/lzd.cpp arc/pack.cpp lh5.cpp arc/squeeze.cpp arc/crunch.cpp arc/squash.cpp pak/crush.cpp - pak/distill.cpp ha.cpp xz.cpp) + pak/distill.cpp ha.cpp xz.cpp + lha/lh_static.cpp lha/lh1.cpp lha/larc.cpp lha/lh_old.cpp) target_link_libraries(tests_run gtest gtest_main "Aaru.Compression.Native") diff --git a/tests/data/larc_lz5.lzs b/tests/data/larc_lz5.lzs new file mode 100644 index 0000000000000000000000000000000000000000..ba1f3a734ae674754521ad79a0dc50c9c391b62c GIT binary patch literal 73153 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 xz-kX)(RvkYAo? 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 Kx$tsHF#rI*=NE|p literal 0 HcmV?d00001 diff --git a/tests/data/lha_lh6.lzh b/tests/data/lha_lh6.lzh new file mode 100644 index 0000000000000000000000000000000000000000..535d3a1af566dc77cfc7868abd5d52cd4d77edab GIT binary patch literal 54239 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 literal 0 HcmV?d00001 diff --git a/tests/data/lharc_lh1.lzh b/tests/data/lharc_lh1.lzh new file mode 100755 index 0000000000000000000000000000000000000000..82e470063ac05a3654f4c1dd72e1de1527186d20 GIT binary patch literal 64995 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 z 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 literal 0 HcmV?d00001 diff --git a/tests/data/pmarc_pm2.pma b/tests/data/pmarc_pm2.pma new file mode 100755 index 0000000000000000000000000000000000000000..9cd15f44eef4c5c693bec63b3a181a61ac0cc5d1 GIT binary patch literal 60416 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 literal 0 HcmV?d00001 diff --git a/tests/lha/larc.cpp b/tests/lha/larc.cpp new file mode 100644 index 0000000..f4dc6f7 --- /dev/null +++ b/tests/lha/larc.cpp @@ -0,0 +1,74 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include + +#include "../../library.h" +#include "../../lha/larc.h" +#include "../crc32.h" +#include "gtest/gtest.h" +#include "lha_helpers.h" + +/* alice29.txt decompressed CRC32 */ +#define EXPECTED_CRC32 0x66007dba +#define EXPECTED_SIZE 152089 + +static uint8_t *lz5_payload; +static lha_test_info lz5_info; + +class lz5Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/larc_lz5.lzs", path); + + lz5_payload = load_lha_payload(filename, &lz5_info); + } + + void TearDown() + { + if(lz5_payload) free(lz5_payload); + } +}; + +TEST_F(lz5Fixture, lz5_decompress) +{ + ASSERT_NE(lz5_payload, nullptr); + EXPECT_EQ(lz5_info.uncompressed_size, (uint32_t)EXPECTED_SIZE); + + size_t out_len = EXPECTED_SIZE; + uint8_t *out_buf = (uint8_t *)malloc(out_len); + + int err = larc_decompress_lz5(lz5_payload, lz5_info.payload_size, out_buf, &out_len); + + EXPECT_EQ(err, 0); + EXPECT_EQ(out_len, (size_t)EXPECTED_SIZE); + + uint32_t crc = crc32_data(out_buf, (uint32_t)out_len); + + free(out_buf); + + EXPECT_EQ(crc, (uint32_t)EXPECTED_CRC32); +} diff --git a/tests/lha/lh1.cpp b/tests/lha/lh1.cpp new file mode 100644 index 0000000..814416c --- /dev/null +++ b/tests/lha/lh1.cpp @@ -0,0 +1,74 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include + +#include "../../library.h" +#include "../../lha/lh1.h" +#include "../crc32.h" +#include "gtest/gtest.h" +#include "lha_helpers.h" + +/* alice29.txt decompressed CRC32 */ +#define EXPECTED_CRC32 0x66007dba +#define EXPECTED_SIZE 152089 + +static uint8_t *lh1_payload; +static lha_test_info lh1_info; + +class lh1Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/lharc_lh1.lzh", path); + + lh1_payload = load_lha_payload(filename, &lh1_info); + } + + void TearDown() + { + if(lh1_payload) free(lh1_payload); + } +}; + +TEST_F(lh1Fixture, lh1_decompress) +{ + ASSERT_NE(lh1_payload, nullptr); + EXPECT_EQ(lh1_info.uncompressed_size, (uint32_t)EXPECTED_SIZE); + + size_t out_len = EXPECTED_SIZE; + uint8_t *out_buf = (uint8_t *)malloc(out_len); + + int err = lha_decompress_lh1(lh1_payload, lh1_info.payload_size, out_buf, &out_len); + + EXPECT_EQ(err, 0); + EXPECT_EQ(out_len, (size_t)EXPECTED_SIZE); + + uint32_t crc = crc32_data(out_buf, (uint32_t)out_len); + + free(out_buf); + + EXPECT_EQ(crc, (uint32_t)EXPECTED_CRC32); +} diff --git a/tests/lha/lh_old.cpp b/tests/lha/lh_old.cpp new file mode 100644 index 0000000..6dd2006 --- /dev/null +++ b/tests/lha/lh_old.cpp @@ -0,0 +1,75 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include + +#include "../../library.h" +#include "../../lha/lh_old.h" +#include "../crc32.h" +#include "gtest/gtest.h" +#include "lha_helpers.h" + +/* PMarc -pm2- decompresses to 152192 bytes */ +#define PM2_EXPECTED_SIZE 152192 +#define PM2_EXPECTED_CRC32 0x1bbf031e + +static uint8_t *pm2_payload; +static lha_test_info pm2_info; + +class pm2Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/pmarc_pm2.pma", path); + + pm2_payload = load_lha_payload(filename, &pm2_info); + } + + void TearDown() + { + if(pm2_payload) free(pm2_payload); + } +}; + +TEST_F(pm2Fixture, pm2_decompress) +{ + ASSERT_NE(pm2_payload, nullptr); + EXPECT_EQ(pm2_info.uncompressed_size, (uint32_t)PM2_EXPECTED_SIZE); + + size_t out_len = PM2_EXPECTED_SIZE; + uint8_t *out_buf = (uint8_t *)malloc(out_len); + + int err = pmarc_decompress_pm2(pm2_payload, pm2_info.payload_size, out_buf, &out_len); + + EXPECT_EQ(err, 0); + EXPECT_EQ(out_len, (size_t)PM2_EXPECTED_SIZE); + + uint32_t crc = crc32_data(out_buf, (uint32_t)out_len); + + free(out_buf); + + /* Validate CRC32 of decompressed data */ + EXPECT_EQ(crc, (uint32_t)PM2_EXPECTED_CRC32); +} diff --git a/tests/lha/lh_static.cpp b/tests/lha/lh_static.cpp new file mode 100644 index 0000000..bb8e5bb --- /dev/null +++ b/tests/lha/lh_static.cpp @@ -0,0 +1,74 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include + +#include "../../library.h" +#include "../../lha/lh_static.h" +#include "../crc32.h" +#include "gtest/gtest.h" +#include "lha_helpers.h" + +/* alice29.txt decompressed CRC32 (same as zoo/lh5 test) */ +#define EXPECTED_CRC32 0x66007dba +#define EXPECTED_SIZE 152089 + +static uint8_t *lh6_payload; +static lha_test_info lh6_info; + +class lh6Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/lha_lh6.lzh", path); + + lh6_payload = load_lha_payload(filename, &lh6_info); + } + + void TearDown() + { + if(lh6_payload) free(lh6_payload); + } +}; + +TEST_F(lh6Fixture, lh6_decompress) +{ + ASSERT_NE(lh6_payload, nullptr); + EXPECT_EQ(lh6_info.uncompressed_size, (uint32_t)EXPECTED_SIZE); + + size_t out_len = EXPECTED_SIZE; + uint8_t *out_buf = (uint8_t *)malloc(out_len); + + int err = lha_decompress_lh6(lh6_payload, lh6_info.payload_size, out_buf, &out_len); + + EXPECT_EQ(err, 0); + EXPECT_EQ(out_len, (size_t)EXPECTED_SIZE); + + uint32_t crc = crc32_data(out_buf, (uint32_t)out_len); + + free(out_buf); + + EXPECT_EQ(crc, (uint32_t)EXPECTED_CRC32); +} diff --git a/tests/lha/lha_helpers.h b/tests/lha/lha_helpers.h new file mode 100644 index 0000000..653fc26 --- /dev/null +++ b/tests/lha/lha_helpers.h @@ -0,0 +1,122 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__TESTS_LHA_HELPERS_H_ +#define AARU_COMPRESSION_NATIVE__TESTS_LHA_HELPERS_H_ + +#include +#include +#include +#include +#include +#include + +/* + * Minimal LHA archive header parser for tests. + * Extracts compressed payload from an LHA/LArc/PMarc archive file. + * Supports header levels 0, 1, and 2. + */ +struct lha_test_info +{ + char method[6]; /* e.g., "-lh6-" */ + uint32_t compressed_size; + uint32_t uncompressed_size; + uint8_t level; + size_t payload_offset; /* offset of compressed data in the file */ + size_t payload_size; /* actual compressed data size */ +}; + +static int parse_lha_header(const uint8_t *data, size_t data_len, struct lha_test_info *info) +{ + if(data_len < 22) return -1; + + uint8_t header_size_byte = data[0]; + uint32_t compressed_size = (uint32_t)data[7] | ((uint32_t)data[8] << 8) | ((uint32_t)data[9] << 16) | + ((uint32_t)data[10] << 24); + uint32_t uncompressed_size = (uint32_t)data[11] | ((uint32_t)data[12] << 8) | ((uint32_t)data[13] << 16) | + ((uint32_t)data[14] << 24); + uint8_t level = data[20]; + + memcpy(info->method, &data[2], 5); + info->method[5] = '\0'; + info->compressed_size = compressed_size; + info->uncompressed_size = uncompressed_size; + info->level = level; + + if(level == 0 || level == 1) + { + size_t base_header = (size_t)header_size_byte + 2; + info->payload_offset = base_header; + info->payload_size = compressed_size; + } + else if(level == 2) + { + uint16_t header_size = (uint16_t)data[0] | ((uint16_t)data[1] << 8); + info->payload_offset = header_size; + info->payload_size = compressed_size; + } + else + { + return -1; + } + + return 0; +} + +static uint8_t *load_lha_payload(const char *filename, struct lha_test_info *info) +{ + FILE *file; + size_t file_size; + uint8_t *file_data; + uint8_t *payload; + + file = fopen(filename, "rb"); + if(!file) return NULL; + + fseek(file, 0, SEEK_END); + file_size = (size_t)ftell(file); + fseek(file, 0, SEEK_SET); + + file_data = (uint8_t *)malloc(file_size); + if(!file_data) { fclose(file); return NULL; } + + fread(file_data, 1, file_size, file); + fclose(file); + + if(parse_lha_header(file_data, file_size, info) != 0) + { + free(file_data); + return NULL; + } + + if(info->payload_offset + info->payload_size > file_size) + { + free(file_data); + return NULL; + } + + payload = (uint8_t *)malloc(info->payload_size); + if(!payload) { free(file_data); return NULL; } + + memcpy(payload, file_data + info->payload_offset, info->payload_size); + free(file_data); + + return payload; +} + +#endif /* AARU_COMPRESSION_NATIVE__TESTS_LHA_HELPERS_H_ */