aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
6b12cd1a8e8a98c5f519298e3d85ca40a3f69600
Aaru/DiscImageChef.Compression/TeleDiskLzh.cs

418 lines
15 KiB
C#
Raw Normal View History

Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : TeleDiskLzh.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Compression algorithms.
//
// --[ Description ] ----------------------------------------------------------
//
// Decompress TeleDisk variant of LZH.
//
// --[ License ] --------------------------------------------------------------
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that
// the following conditions are met:
Update copyright year.
2018-12-29 17:34:38 +00:00
//
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
// following disclaimer.
Update copyright year.
2018-12-29 17:34:38 +00:00
//
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
// following disclaimer in the documentation and/or other materials provided with the distribution.
Update copyright year.
2018-12-29 17:34:38 +00:00
//
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written permission.
Update copyright year.
2018-12-29 17:34:38 +00:00
//
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ----------------------------------------------------------------------------
Update copyright year.
2018-12-29 17:34:38 +00:00
// Copyright © 2011-2019 Natalia Portillo
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
// Copyright © 2017 Miodrag Milanovic
// Copyright © 1988 Haruhiko OKUMURA
// Copyright © 1988 Haruyasu YOSHIZAKI
// Copyright © 1988 Kenji RIKITAKE
// ****************************************************************************/
using System;
using System.IO;
namespace DiscImageChef.Compression
{
/*
* Based on Japanese version 29-NOV-1988
* LZSS coded by Haruhiko OKUMURA
* Adaptive Huffman Coding coded by Haruyasu YOSHIZAKI
* Edited and translated to English by Kenji RIKITAKE
*/
public class TeleDiskLzh
{
const int BUFSZ = 512;
/* LZSS Parameters */
const int N = 4096; /* Size of string buffer */
const int F = 60; /* Size of look-ahead buffer */
const int THRESHOLD = 2;
const int NIL = N; /* End of tree's node */
/* Huffman coding parameters */
const int N_CHAR = 256 - THRESHOLD + F;
/* character code (= 0..N_CHAR-1) */
const int T = N_CHAR * 2 - 1; /* Size of table */
const int ROOT = T - 1; /* root position */
const int MAX_FREQ = 0x8000;
/*
* Tables for encoding/decoding upper 6 bits of
* sliding dictionary pointer
*/
/* decoder table */
readonly byte[] d_code =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
0x09, 0x09, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x10, 0x10,
0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, 0x14,
0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A,
0x1B, 0x1B, 0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C,
0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
0x3C, 0x3D, 0x3E, 0x3F
};
readonly byte[] d_len =
{
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08
};
readonly Stream inStream;
ushort[] freq = new ushort[T + 1]; /* cumulative freq table */
ushort getbuf;
byte getlen;
/*
* pointing parent nodes.
* area [T..(T + N_CHAR - 1)] are pointers for leaves
*/
short[] prnt = new short[T + N_CHAR];
/* pointing children nodes (son[], son[] + 1)*/
short[] son = new short[T];
Tdlzhuf tdctl;
byte[] text_buf = new byte[N + F - 1];
public TeleDiskLzh(Stream dataStream)
{
int i;
getbuf = 0;
getlen = 0;
tdctl = new Tdlzhuf();
tdctl.Ibufcnt = tdctl.Ibufndx = 0; // input buffer is empty
tdctl.Bufcnt = 0;
StartHuff();
for(i = 0; i < N - F; i++) text_buf[i] = 0x20;
tdctl.R = N - F;
inStream = dataStream;
}
/* DeCompression
split out initialization code to init_Decode()
*/
public int Decode(out byte[] buf, int len) /* Decoding/Uncompressing */
{
short c;
buf = new byte[len];
int count; // was an unsigned long, seems unnecessary
for(count = 0; count < len;)
Code cleanup.
2018-06-22 08:08:38 +01:00
if(tdctl.Bufcnt == 0)
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
{
if((c = DecodeChar()) < 0) return count; // fatal error
if(c < 256)
{
buf[count] = (byte)c;
text_buf[tdctl.R++] = (byte)c;
tdctl.R &= N - 1;
count++;
}
else
{
short pos;
if((pos = DecodePosition()) < 0) return count; // fatal error
tdctl.Bufpos = (ushort)((tdctl.R - pos - 1) & (N - 1));
Code cleanup.
2018-06-22 08:08:38 +01:00
tdctl.Bufcnt = (ushort)(c - 255 + THRESHOLD);
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
tdctl.Bufndx = 0;
}
}
else
{
// still chars from last string
while(tdctl.Bufndx < tdctl.Bufcnt && count < len)
{
c = text_buf[(tdctl.Bufpos + tdctl.Bufndx) & (N - 1)];
buf[count] = (byte)c;
tdctl.Bufndx++;
text_buf[tdctl.R++] = (byte)c;
tdctl.R &= N - 1;
count++;
}
// reset bufcnt after copy string from text_buf[]
if(tdctl.Bufndx >= tdctl.Bufcnt) tdctl.Bufndx = tdctl.Bufcnt = 0;
}
return count; // count == len, success
}
long DataRead(out byte[] buf, long size)
{
if(size > inStream.Length - inStream.Position) size = inStream.Length - inStream.Position;
buf = new byte[size];
inStream.Read(buf, 0, (int)size);
return size;
}
int NextWord()
{
if(tdctl.Ibufndx >= tdctl.Ibufcnt)
{
tdctl.Ibufndx = 0;
tdctl.Ibufcnt = (ushort)DataRead(out tdctl.Inbuf, BUFSZ);
if(tdctl.Ibufcnt <= 0) return -1;
}
while(getlen <= 8)
{
// typically reads a word at a time
getbuf |= (ushort)(tdctl.Inbuf[tdctl.Ibufndx++] << (8 - getlen));
getlen += 8;
}
return 0;
}
int GetBit() /* get one bit */
{
if(NextWord() < 0) return -1;
short i = (short)getbuf;
getbuf <<= 1;
getlen--;
return i < 0 ? 1 : 0;
}
int GetByte() /* get a byte */
{
if(NextWord() != 0) return -1;
ushort i = getbuf;
getbuf <<= 8;
getlen -= 8;
i = (ushort)(i >> 8);
return i;
}
/* initialize freq tree */
void StartHuff()
{
int i;
for(i = 0; i < N_CHAR; i++)
{
Code cleanup.
2018-06-22 08:08:38 +01:00
freq[i] = 1;
son[i] = (short)(i + T);
prnt[i + T] = (short)i;
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
}
i = 0;
int j = N_CHAR;
while(j <= ROOT)
{
freq[j] = (ushort)(freq[i] + freq[i + 1]);
son[j] = (short)i;
prnt[i] = prnt[i + 1] = (short)j;
i += 2;
j++;
}
freq[T] = 0xffff;
prnt[ROOT] = 0;
}
/* reconstruct freq tree */
void Reconst()
{
short i, k;
/* halven cumulative freq for leaf nodes */
short j = 0;
Code cleanup.
2018-06-22 08:08:38 +01:00
for(i = 0; i < T; i++)
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
if(son[i] >= T)
{
freq[j] = (ushort)((freq[i] + 1) / 2);
son[j] = son[i];
j++;
}
/* make a tree : first, connect children nodes */
for(i = 0, j = N_CHAR; j < T; i += 2, j++)
{
Code cleanup.
2018-06-22 08:08:38 +01:00
k = (short)(i + 1);
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
ushort f = freq[j] = (ushort)(freq[i] + freq[k]);
Code cleanup.
2018-06-22 08:08:38 +01:00
for(k = (short)(j - 1); f < freq[k]; k--) { }
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
k++;
ushort l = (ushort)((j - k) * 2);
Array.ConstrainedCopy(freq, k, freq, k + 1, l);
freq[k] = f;
Array.ConstrainedCopy(son, k, son, k + 1, l);
son[k] = i;
}
/* connect parent nodes */
Code cleanup.
2018-06-22 08:08:38 +01:00
for(i = 0; i < T; i++)
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
if((k = son[i]) >= T)
prnt[k] = i;
else
prnt[k] = prnt[k + 1] = i;
}
/* update freq tree */
void Update(int c)
{
if(freq[ROOT] == MAX_FREQ) Reconst();
c = prnt[c + T];
do
{
int k = ++freq[c];
/* swap nodes to keep the tree freq-ordered */
int l;
if(k <= freq[l = c + 1]) continue;
while(k > freq[++l]) { }
l--;
freq[c] = freq[l];
freq[l] = (ushort)k;
Code cleanup.
2018-06-22 08:08:38 +01:00
int i = son[c];
prnt[i] = (short)l;
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
if(i < T) prnt[i + 1] = (short)l;
Code cleanup.
2018-06-22 08:08:38 +01:00
int j = son[l];
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
son[l] = (short)i;
Code cleanup.
2018-06-22 08:08:38 +01:00
prnt[j] = (short)c;
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
if(j < T) prnt[j + 1] = (short)c;
Code cleanup.
2018-06-22 08:08:38 +01:00
son[c] = (short)j;
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
c = l;
}
while((c = prnt[c]) != 0); /* do it until reaching the root */
}
short DecodeChar()
{
ushort c = (ushort)son[ROOT];
/*
* start searching tree from the root to leaves.
* choose node #(son[]) if input bit == 0
* else choose #(son[]+1) (input bit == 1)
*/
while(c < T)
{
int ret;
if((ret = GetBit()) < 0) return -1;
c += (ushort)ret;
c = (ushort)son[c];
}
c -= T;
Update(c);
return (short)c;
}
short DecodePosition()
{
Code cleanup.
2018-06-22 08:08:38 +01:00
short bit;
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
/* decode upper 6 bits from given table */
if((bit = (short)GetByte()) < 0) return -1;
ushort i = (ushort)bit;
ushort c = (ushort)(d_code[i] << 6);
Refactor TeleDisk LZH class.
2018-01-21 15:39:26 +00:00
ushort j = d_len[i];
Split TeleDisk's LZH to a separate class.
2018-01-21 12:37:32 +00:00
/* input lower 6 bits directly */
j -= 2;
while(j-- > 0)
{
if((bit = (short)GetBit()) < 0) return -1;
i = (ushort)((i << 1) + bit);
}
return (short)(c | (i & 0x3f));
}
/* update when cumulative frequency */
/* reaches to this value */
struct Tdlzhuf
{
public ushort R,
Bufcnt,
Bufndx,
Bufpos, // string buffer
// the following to allow block reads from input in next_word()
Ibufcnt,
Ibufndx; // input buffer counters
public byte[] Inbuf; // input buffer
}
}
}
Reference in New Issue Copy Permalink