mirror of
https://github.com/DaanVandenBosch/phantasmal-world.git
synced 2025-04-04 22:58:29 +08:00
299 lines
8.7 KiB
TypeScript
299 lines
8.7 KiB
TypeScript
/**
|
|
* This code is based on the Sylverant PRS compression code written by Lawrence Sebald.
|
|
*/
|
|
|
|
import { ArrayBufferCursor } from '../../ArrayBufferCursor';
|
|
|
|
export function compress(src: ArrayBufferCursor): ArrayBufferCursor {
|
|
const ctx = new Context(src);
|
|
const hashTable = new HashTable();
|
|
|
|
if (ctx.src.size <= 3) {
|
|
// Make a literal copy of the input.
|
|
while (ctx.src.bytesLeft) {
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
}
|
|
} else {
|
|
// Add the first two "strings" to the hash table.
|
|
hashTable.put(hashTable.hash(ctx.src), 0);
|
|
ctx.src.seek(1);
|
|
hashTable.put(hashTable.hash(ctx.src), 1);
|
|
ctx.src.seek(-1);
|
|
|
|
// Copy the first two bytes as literals.
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
|
|
while (ctx.src.bytesLeft > 1) {
|
|
let [offset, mlen] = ctx.findLongestMatch(hashTable, false);
|
|
|
|
if (mlen > 0) {
|
|
ctx.src.seek(1);
|
|
const [offset2, mlen2] = ctx.findLongestMatch(hashTable, true);
|
|
ctx.src.seek(-1);
|
|
|
|
// Did the "lazy match" produce something more compressed?
|
|
if (mlen2 > mlen) {
|
|
let copyLiteral = true;
|
|
// Check if it is a good idea to switch from a short match to a long one.
|
|
if (mlen >= 2 && mlen <= 5 && offset2 < offset) {
|
|
if (offset >= -256 && offset2 < -256) {
|
|
if (mlen2 - mlen < 3) {
|
|
copyLiteral = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (copyLiteral) {
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// What kind of match did we find?
|
|
if (mlen >= 2 && mlen <= 5 && offset >= -256) {
|
|
// Short match.
|
|
ctx.setBit(0);
|
|
ctx.setBit(0);
|
|
ctx.setBit((mlen - 2) & 0x02);
|
|
ctx.setBit((mlen - 2) & 0x01);
|
|
ctx.writeLiteral(offset & 0xFF);
|
|
ctx.addIntermediates(hashTable, mlen);
|
|
continue;
|
|
} else if (mlen >= 3 && mlen <= 9) {
|
|
// Long match, short length.
|
|
ctx.setBit(0);
|
|
ctx.setBit(1);
|
|
ctx.writeLiteral(((offset & 0x1F) << 3) | ((mlen - 2) & 0x07));
|
|
ctx.writeLiteral(offset >> 5);
|
|
ctx.addIntermediates(hashTable, mlen);
|
|
continue;
|
|
} else if (mlen > 9) {
|
|
// Long match, long length.
|
|
if (mlen > 256) {
|
|
mlen = 256;
|
|
}
|
|
|
|
ctx.setBit(0);
|
|
ctx.setBit(1);
|
|
ctx.writeLiteral((offset & 0x1F) << 3);
|
|
ctx.writeLiteral(offset >> 5);
|
|
ctx.writeLiteral(mlen - 1);
|
|
ctx.addIntermediates(hashTable, mlen);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// If we get here, we didn't find a suitable match, so just we just make a literal copy.
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
}
|
|
|
|
// If there's a left over byte at the end, make a literal copy.
|
|
if (ctx.src.bytesLeft) {
|
|
ctx.setBit(1);
|
|
ctx.copyLiteral();
|
|
}
|
|
}
|
|
|
|
ctx.writeEof();
|
|
|
|
return ctx.dst.seekStart(0);
|
|
}
|
|
|
|
const MAX_WINDOW = 0x2000;
|
|
const WINDOW_MASK = MAX_WINDOW - 1;
|
|
const HASH_SIZE = 1 << 8;
|
|
|
|
class Context {
|
|
src: ArrayBufferCursor;
|
|
dst: ArrayBufferCursor;
|
|
flags: number;
|
|
flagBitsLeft: number;
|
|
flagOffset: number;
|
|
|
|
constructor(cursor: ArrayBufferCursor) {
|
|
this.src = cursor;
|
|
this.dst = new ArrayBufferCursor(cursor.size, cursor.littleEndian);
|
|
this.flags = 0;
|
|
this.flagBitsLeft = 0;
|
|
this.flagOffset = 0;
|
|
}
|
|
|
|
setBit(bit: number): void {
|
|
if (!this.flagBitsLeft--) {
|
|
// Write out the flags to their position in the file, and store the next flags byte position.
|
|
const pos = this.dst.position;
|
|
this.dst
|
|
.seekStart(this.flagOffset)
|
|
.writeU8(this.flags)
|
|
.seekStart(pos)
|
|
.writeU8(0); // Placeholder for the next flags byte.
|
|
this.flagOffset = pos;
|
|
this.flagBitsLeft = 7;
|
|
}
|
|
|
|
this.flags >>>= 1;
|
|
|
|
if (bit) {
|
|
this.flags |= 0x80;
|
|
}
|
|
}
|
|
|
|
copyLiteral(): void {
|
|
this.dst.writeU8(this.src.u8());
|
|
}
|
|
|
|
writeLiteral(value: number): void {
|
|
this.dst.writeU8(value);
|
|
}
|
|
|
|
writeFinalFlags(): void {
|
|
this.flags >>>= this.flagBitsLeft;
|
|
const pos = this.dst.position;
|
|
this.dst
|
|
.seekStart(this.flagOffset)
|
|
.writeU8(this.flags)
|
|
.seekStart(pos);
|
|
}
|
|
|
|
writeEof(): void {
|
|
this.setBit(0);
|
|
this.setBit(1);
|
|
|
|
this.writeFinalFlags();
|
|
|
|
this.writeLiteral(0);
|
|
this.writeLiteral(0);
|
|
}
|
|
|
|
matchLength(s2: number): number {
|
|
const array = this.src.uint8ArrayView();
|
|
let len = 0;
|
|
let s1 = this.src.position;
|
|
|
|
while (s1 < array.byteLength && array[s1] === array[s2]) {
|
|
++len;
|
|
++s1;
|
|
++s2;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
findLongestMatch(hashTable: HashTable, lazy: boolean): [number, number] {
|
|
if (!this.src.bytesLeft) {
|
|
return [0, 0];
|
|
}
|
|
|
|
// Figure out where we're looking.
|
|
const hash = hashTable.hash(this.src);
|
|
|
|
// If there is nothing in the table at that point, bail out now.
|
|
let entry = hashTable.get(hash);
|
|
|
|
if (entry === null) {
|
|
if (!lazy) {
|
|
hashTable.put(hash, this.src.position);
|
|
}
|
|
|
|
return [0, 0];
|
|
}
|
|
|
|
// If we'd go outside the window, truncate the hash chain now.
|
|
if (this.src.position - entry > MAX_WINDOW) {
|
|
hashTable.hashToOffset[hash] = null;
|
|
|
|
if (!lazy) {
|
|
hashTable.put(hash, this.src.position);
|
|
}
|
|
|
|
return [0, 0];
|
|
}
|
|
|
|
// Ok, we have something in the hash table that matches the hash value.
|
|
// Follow the chain to see if we have an actual string match, and find the longest match.
|
|
let longestLength = 0;
|
|
let longestMatch = 0;
|
|
|
|
while (entry != null) {
|
|
const mlen = this.matchLength(entry);
|
|
|
|
if (mlen > longestLength || mlen >= 256) {
|
|
longestLength = mlen;
|
|
longestMatch = entry;
|
|
}
|
|
|
|
// Follow the chain, making sure not to exceed a difference of MAX_WINDOW.
|
|
let entry2 = hashTable.prev(entry);
|
|
|
|
if (entry2 !== null) {
|
|
// If we'd go outside the window, truncate the hash chain now.
|
|
if (this.src.position - entry2 > MAX_WINDOW) {
|
|
hashTable.setPrev(entry, null);
|
|
entry2 = null;
|
|
}
|
|
}
|
|
|
|
entry = entry2;
|
|
}
|
|
|
|
// Add our current string to the hash.
|
|
if (!lazy) {
|
|
hashTable.put(hash, this.src.position);
|
|
}
|
|
|
|
// Did we find a match?
|
|
const offset = longestLength > 0 ? longestMatch - this.src.position : 0;
|
|
return [offset, longestLength];
|
|
}
|
|
|
|
addIntermediates(hashTable: HashTable, len: number): void {
|
|
this.src.seek(1);
|
|
|
|
for (let i = 1; i < len; ++i) {
|
|
const hash = hashTable.hash(this.src);
|
|
hashTable.put(hash, this.src.position);
|
|
this.src.seek(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
class HashTable {
|
|
hashToOffset: Array<number | null> = new Array(HASH_SIZE).fill(null);
|
|
maskedOffsetToPrev: Array<number | null> = new Array(MAX_WINDOW).fill(null);
|
|
|
|
hash(cursor: ArrayBufferCursor): number {
|
|
let hash = cursor.u8();
|
|
|
|
if (cursor.bytesLeft) {
|
|
hash ^= cursor.u8();
|
|
cursor.seek(-1);
|
|
}
|
|
|
|
cursor.seek(-1);
|
|
return hash;
|
|
}
|
|
|
|
get(hash: number): number | null {
|
|
return this.hashToOffset[hash];
|
|
}
|
|
|
|
put(hash: number, offset: number): void {
|
|
this.setPrev(offset, this.hashToOffset[hash]);
|
|
this.hashToOffset[hash] = offset;
|
|
}
|
|
|
|
prev(offset: number): number | null {
|
|
return this.maskedOffsetToPrev[offset & WINDOW_MASK];
|
|
}
|
|
|
|
setPrev(offset: number, prevOffset: number | null): void {
|
|
this.maskedOffsetToPrev[offset & WINDOW_MASK] = prevOffset;
|
|
}
|
|
}
|