path: root/src/modules/common/lzsscomprs.cpp

/******************************************************************************
 *  lzsscomprs.cpp   - code for class 'LZSSCompress'- a driver class that
 *			provides LZSS compression
 */

#include <string.h>
#include <stdlib.h>
#include <lzsscomprs.h>


/******************************************************************************
 * LZSSCompress Statics
 */

// m_ring_buffer is a text buffer.  It contains "nodes" of
// uncompressed text that can be indexed by position.  That is,
// a substring of the ring buffer can be indexed by a position
// and a length.  When decoding, the compressed text may contain
// a position in the ring buffer and a count of the number of
// bytes from the ring buffer that are to be moved into the
// uncompressed buffer.  
//
// This ring buffer is not maintained as part of the compressed
// text.  Instead, it is reconstructed dynamically.  That is,
// it starts out empty and gets built as the text is decompressed.
//
// The ring buffer contain N bytes, with an additional F - 1 bytes
// to facilitate string comparison.

unsigned char LZSSCompress::m_ring_buffer[N + F - 1];

// m_match_position and m_match_length are set by InsertNode().
//
// These variables indicate the position in the ring buffer 
// and the number of characters at that position that match
// a given string.

short int LZSSCompress::m_match_position;
short int LZSSCompress::m_match_length;

// m_lson, m_rson, and m_dad are the Japanese way of referring to
// a tree structure.  The dad is the parent and it has a right and
// left son (child).
//
// For i = 0 to N-1, m_rson[i] and m_lson[i] will be the right 
// and left children of node i.  
//
// For i = 0 to N-1, m_dad[i] is the parent of node i.
//
// For i = 0 to 255, rson[N + i + 1] is the root of the tree for 
// strings that begin with the character i.  Note that this requires 
// one byte characters.
//
// These nodes store values of 0...(N-1).  Memory requirements
// can be reduces by using 2-byte integers instead of full 4-byte
// integers (for 32-bit applications).  Therefore, these are 
// defined as "short ints."

short int LZSSCompress::m_lson[N + 1];
short int LZSSCompress::m_rson[N + 257];
short int LZSSCompress::m_dad[N + 1];


/******************************************************************************
 * LZSSCompress Constructor - Initializes data for instance of LZSSCompress
 *
 */

LZSSCompress::LZSSCompress() : SWCompress() {
}


/******************************************************************************
 * LZSSCompress Destructor - Cleans up instance of LZSSCompress
 */

LZSSCompress::~LZSSCompress() {
}


/******************************************************************************
 * LZSSCompress::InitTree	- This function initializes the tree nodes to
 *							"empty" states. 
 */

void LZSSCompress::InitTree(void) {
	int  i;

	// For i = 0 to N - 1, m_rson[i] and m_lson[i] will be the right
	// and left children of node i.  These nodes need not be
	// initialized.  However, for debugging purposes, it is nice to
	// have them initialized.  Since this is only used for compression
	// (not decompression), I don't mind spending the time to do it.
	//
	// For the same range of i, m_dad[i] is the parent of node i.
	// These are initialized to a known value that can represent
	// a "not used" state.
	
	for (i = 0; i < N; i++) {
		m_lson[i] = NOT_USED;
		m_rson[i] = NOT_USED;
		m_dad[i] = NOT_USED;
	}

	// For i = 0 to 255, m_rson[N + i + 1] is the root of the tree
	// for strings that begin with the character i.  This is why
	// the right child array is larger than the left child array.
	// These are also initialzied to a "not used" state.
	//
	// Note that there are 256 of these, one for each of the possible
	// 256 characters.

	for (i = N + 1; i <= (N + 256); i++) {
		m_rson[i] = NOT_USED;
	}
}


/******************************************************************************
 * LZSSCompress::InsertNode	- This function inserts a string from the ring
 *							buffer into one of the trees.  It loads the
 *							match position and length member variables
 *							for the longest match.
 *	
 *							The string to be inserted is identified by
 *							the parameter Pos, A full F bytes are
 *							inserted.  So,
 *							m_ring_buffer[Pos ... Pos+F-1]
 *							are inserted.
 *
 *							If the matched length is exactly F, then an
 *							old node is removed in favor of the new one
 *							(because the old one will be deleted
 *							sooner).
 *
 *							Note that Pos plays a dual role.  It is
 *							used as both a position in the ring buffer
 *							and also as a tree node.
 *							m_ring_buffer[Pos] defines a character that
 *							is used to identify a tree node.
 *
 * ENT:	pos	- position in the buffer
 */

void LZSSCompress::InsertNode(short int Pos)
{
	short int i;
	short int p;
	int cmp;
	unsigned char * key;

/*
	ASSERT(Pos >= 0);
	ASSERT(Pos < N);
*/

	cmp = 1;
	key = &(m_ring_buffer[Pos]);

	// The last 256 entries in m_rson contain the root nodes for
	// strings that begin with a letter.  Get an index for the
	// first letter in this string.

	p = (short int) (N + 1 + key[0]);

	// Set the left and right tree nodes for this position to "not
	// used."

	m_lson[Pos] = NOT_USED;
	m_rson[Pos] = NOT_USED;

	// Haven't matched anything yet.

	m_match_length = 0;

	for ( ; ; ) {
		if (cmp >= 0) {
			if (m_rson[p] != NOT_USED) {
				p = m_rson[p];
			}
			else {
				m_rson[p] = Pos;
				m_dad[Pos] = p;
				return;
			}
		}
		else {
			if (m_lson[p] != NOT_USED) {
				p = m_lson[p];
			}
			else {
				m_lson[p] = Pos;
				m_dad[Pos] = p;
				return;
			}
		}

		// Should we go to the right or the left to look for the
		// next match?

		for (i = 1; i < F; i++) {
			cmp = key[i] - m_ring_buffer[p + i];
			if (cmp != 0)
				break;
		}

		if (i > m_match_length) {
			m_match_position = p;
			m_match_length = i;

			if (i >= F)
				break;
		}
	}

	m_dad[Pos] = m_dad[p];
	m_lson[Pos] = m_lson[p];
	m_rson[Pos] = m_rson[p];

	m_dad[ m_lson[p] ] = Pos;
	m_dad[ m_rson[p] ] = Pos;

	if (m_rson[ m_dad[p] ] == p) {
		m_rson[ m_dad[p] ] = Pos;
	}
	else {
		m_lson[ m_dad[p] ] = Pos;
	}

	// Remove "p"

	m_dad[p] = NOT_USED;
}


/******************************************************************************
 * LZSSCompress::DeleteNode	- This function removes the node "Node" from the
 *							tree.
 *
 * ENT:	node	- node to be removed
 */

void LZSSCompress::DeleteNode(short int Node)
{
	short int  q;

/*
	ASSERT(Node >= 0);
	ASSERT(Node < (N+1));
*/

	if (m_dad[Node] == NOT_USED) { // not in tree, nothing to do
		return;
	}

	if (m_rson[Node] == NOT_USED) {
		q = m_lson[Node];
	}
	else if (m_lson[Node] == NOT_USED) {
		q = m_rson[Node];
	}
	else {
		q = m_lson[Node];
		if (m_rson[q] != NOT_USED) {
			do {
				q = m_rson[q];
			} while (m_rson[q] != NOT_USED);

			m_rson[ m_dad[q] ] = m_lson[q];
			m_dad[ m_lson[q] ] = m_dad[q];
			m_lson[q] = m_lson[Node];
			m_dad[ m_lson[Node] ] = q;
		}

		m_rson[q] = m_rson[Node];
		m_dad[ m_rson[Node] ] = q;
	}

	m_dad[q] = m_dad[Node];

	if (m_rson[ m_dad[Node] ] == Node) {
		m_rson[ m_dad[Node] ] = q;
	}
	else {
		m_lson[ m_dad[Node] ] = q;
	}

	m_dad[Node] = NOT_USED;
}


/******************************************************************************
 * LZSSCompress::Encode	- This function "encodes" the input stream into the
 *						output stream.
 *						The GetChars() and SendChars() functions are
 *						used to separate this method from the actual
 *						i/o.
 * 		NOTE:			must set zlen for parent class to know length of
 * 						compressed buffer.
 */

void LZSSCompress::Encode(void)
{
	short int i;						// an iterator
	short int r;						// node number in the binary tree
	short int s;						// position in the ring buffer
	unsigned short int len;			 // len of initial string
	short int last_match_length;		// length of last match
	short int code_buf_pos;			 // position in the output buffer
	unsigned char code_buf[17];		 // the output buffer
	unsigned char mask;				 // bit mask for byte 0 of out buf
	unsigned char c;					// character read from string

	// Start with a clean tree.

	InitTree();
	direct = 0;	// set direction needed by parent [Get|Send]Chars()

	// code_buf[0] works as eight flags.  A "1" represents that the
	// unit is an unencoded letter (1 byte), and a "0" represents
	// that the next unit is a <position,length> pair (2 bytes).
	//
	// code_buf[1..16] stores eight units of code.  Since the best
	// we can do is store eight <position,length> pairs, at most 16 
	// bytes are needed to store this.
	//
	// This is why the maximum size of the code buffer is 17 bytes.

	code_buf[0] = 0;
	code_buf_pos = 1;

	// Mask iterates over the 8 bits in the code buffer.  The first
	// character ends up being stored in the low bit.
	//
	//  bit   8   7   6   5   4   3   2   1
	//		|						   |
	//		|			 first sequence in code buffer
	//		|
	//	  last sequence in code buffer		

	mask = 1;

	s = 0;
	r = (short int) N - (short int) F;

	// Initialize the ring buffer with spaces...

	// Note that the last F bytes of the ring buffer are not filled.
	// This is because those F bytes will be filled in immediately
	// with bytes from the input stream.

	memset(m_ring_buffer, ' ', N - F);
	
	// Read F bytes into the last F bytes of the ring buffer.
	//
	// This function loads the buffer with X characters and returns
	// the actual amount loaded.

	len = GetChars((char *) &(m_ring_buffer[r]), F);

	// Make sure there is something to be compressed.

	if (len == 0)
		return;

	// Insert the F strings, each of which begins with one or more
	// 'space' characters.  Note the order in which these strings
	// are inserted.  This way, degenerate trees will be less likely
	// to occur.

	for (i = 1; i <= F; i++) {
		InsertNode((short int) (r - i));
	}

	// Finally, insert the whole string just read.  The
	// member variables match_length and match_position are set.

	InsertNode(r);

	// Now that we're preloaded, continue till done.

	do {

		// m_match_length may be spuriously long near the end of
		// text.

		if (m_match_length > len) {
			m_match_length = len;
		}

		// Is it cheaper to store this as a single character?  If so,
		// make it so.

		if (m_match_length < THRESHOLD) {
			// Send one character.  Remember that code_buf[0] is the
			// set of flags for the next eight items.

			m_match_length = 1;	 
			code_buf[0] |= mask;  
			code_buf[code_buf_pos++] = m_ring_buffer[r];
		}

		// Otherwise, we do indeed have a string that can be stored
		// compressed to save space.

		else {
			// The next 16 bits need to contain the position (12 bits)
			// and the length (4 bits).

			code_buf[code_buf_pos++] = (unsigned char) m_match_position;
			code_buf[code_buf_pos++] = (unsigned char) (
				((m_match_position >> 4) & 0xf0) | 
				(m_match_length - THRESHOLD) );
		}

		// Shift the mask one bit to the left so that it will be ready
		// to store the new bit.

		mask = (unsigned char) (mask << 1);

		// If the mask is now 0, then we know that we have a full set
		// of flags and items in the code buffer.  These need to be
		// output.

		if (!mask) {
			// code_buf is the buffer of characters to be output.
			// code_buf_pos is the number of characters it contains.

			SendChars((char *) code_buf, code_buf_pos);

			// Reset for next buffer...

			code_buf[0] = 0;
			code_buf_pos = 1;
			mask = 1;
		}

		last_match_length = m_match_length;

		// Delete old strings and read new bytes...

		for (i = 0; i < last_match_length; i++) {
			// Get next character...

			if (GetChars((char *) &c, 1) != 1)
				break;

			// Delete "old strings"

			DeleteNode(s);

			// Put this character into the ring buffer.
			//		  
			// The original comment here says "If the position is near
			// the end of the buffer, extend the buffer to make
			// string comparison easier."
			//
			// That's a little misleading, because the "end" of the 
			// buffer is really what we consider to be the "beginning"
			// of the buffer, that is, positions 0 through F.
			//
			// The idea is that the front end of the buffer is duplicated
			// into the back end so that when you're looking at characters
			// at the back end of the buffer, you can index ahead (beyond
			// the normal end of the buffer) and see the characters
			// that are at the front end of the buffer wihtout having
			// to adjust the index.
			//
			// That is...
			//
			//	  1234xxxxxxxxxxxxxxxxxxxxxxxxxxxxx1234
			//	  |							   |  |
			//	  position 0		  end of buffer  |
			//										 |
			//				  duplicate of front of buffer

			m_ring_buffer[s] = c;

			if (s < F - 1) {
				m_ring_buffer[s + N] = c;
			}

			// Increment the position, and wrap around when we're at
			// the end.  Note that this relies on N being a power of 2.

			s = (short int) ( (s + 1) & (N - 1) );
			r = (short int) ( (r + 1) & (N - 1) );

			// Register the string that is found in 
			// m_ring_buffer[r..r+F-1].

			InsertNode(r);
		}

		// If we didn't quit because we hit the last_match_length,
		// then we must have quit because we ran out of characters
		// to process.

		while (i++ < last_match_length) {							  
			DeleteNode(s);

			s = (short int) ( (s + 1) & (N - 1) );
			r = (short int) ( (r + 1) & (N - 1) );

			// Note that len hitting 0 is the key that causes the
			// do...while() to terminate.  This is the only place
			// within the loop that len is modified.
			//
			// Its original value is F (or a number less than F for
			// short strings).

			if (--len) {
				InsertNode(r);	   /* buffer may not be empty. */
			}
		}

		// End of do...while() loop.  Continue processing until there
		// are no more characters to be compressed.  The variable
		// "len" is used to signal this condition.
	} while (len > 0);

	// There could still be something in the output buffer.  Send it
	// now.

	if (code_buf_pos > 1) {
		// code_buf is the encoded string to send.
		// code_buf_ptr is the number of characters.

		SendChars((char *) code_buf, code_buf_pos);
	}


	// must set zlen for parent class to know length of compressed buffer
	zlen = zpos;
}


/******************************************************************************
 * LZSSCompress::Decode	- This function "decodes" the input stream into the
 *						output stream.
 *						The GetChars() and SendChars() functions are
 *						used to separate this method from the actual
 *						i/o.
 */

void LZSSCompress::Decode(void)
{
	int k;
	int r;							  // node number
	unsigned char c[F];				 // an array of chars
	unsigned char flags;				// 8 bits of flags
	int flag_count;					 // which flag we're on
	short int pos;					  // position in the ring buffer
	short int len;					  // number of chars in ring buffer
	unsigned long totalLen = 0;

	direct = 1;	// set direction needed by parent [Get|Send]Chars()

	// Initialize the ring buffer with a common string.
	//
	// Note that the last F bytes of the ring buffer are not filled.

	memset(m_ring_buffer, ' ', N - F);
	
	r = N - F;

	flags = (char) 0;
	flag_count = 0;

	for ( ; ; ) {

		// If there are more bits of interest in this flag, then
		// shift that next interesting bit into the 1's position.
		//
		// If this flag has been exhausted, the next byte must 
		// be a flag.

		if (flag_count > 0) {
			flags = (unsigned char) (flags >> 1);
			flag_count--;
		}
		else {
			// Next byte must be a flag.

			if (GetChars((char *) &flags, 1) != 1)
				break;

			// Set the flag counter.  While at first it might appear
			// that this should be an 8 since there are 8 bits in the
			// flag, it should really be a 7 because the shift must
			// be performed 7 times in order to see all 8 bits.

			flag_count = 7;
		}

		// If the low order bit of the flag is now set, then we know
		// that the next byte is a single, unencoded character.

		if (flags & 1) {
			if (GetChars((char *) c, 1) != 1)
				break;

			if (SendChars((char *) c, 1) != 1) {
				totalLen++;
				break;
			}

			// Add to buffer, and increment to next spot. Wrap at end.

			m_ring_buffer[r] = c[0];
			r = (short int) ( (r + 1) & (N - 1) );
		}

		// Otherwise, we know that the next two bytes are a
		// <position,length> pair.  The position is in 12 bits and
		// the length is in 4 bits.

		else {
			// Original code:
			//  if ((i = getc(infile)) == EOF)
			//	  break;
			//  if ((j = getc(infile)) == EOF)
			//	  break;
			//  i |= ((j & 0xf0) << 4);	
			//  j = (j & 0x0f) + THRESHOLD;
			//
			// I've modified this to only make one input call, and
			// have changed the variable names to something more
			// obvious.

			if (GetChars((char *) c, 2) != 2)
				break;

			// Convert these two characters into the position and
			// length.  Note that the length is always at least
			// THRESHOLD, which is why we're able to get a length
			// of 18 out of only 4 bits.

			pos = (short int) ( c[0] | ((c[1] & 0xf0) << 4) );

			len = (short int) ( (c[1] & 0x0f) + THRESHOLD );

			// There are now "len" characters at position "pos" in
			// the ring buffer that can be pulled out.  Note that
			// len is never more than F.

			for (k = 0; k < len; k++) {
				c[k] = m_ring_buffer[(pos + k) & (N - 1)];

				// Add to buffer, and increment to next spot. Wrap at end.

				m_ring_buffer[r] = c[k];
				r = (short int) ( (r + 1) & (N - 1) );
			}

			// Add the "len" :characters to the output stream.

			if (SendChars((char *) c, len) != (unsigned int)len) {
				totalLen += len;
				break;
			}
		}
	}
	slen = totalLen;
}