xref: /haiku/src/add-ons/print/drivers/pcl6/DeltaRowCompression.h (revision 568716bed76d9711e95cd1604313be2f142505c0)

/*
** DeltaRowCompression.h
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#ifndef _DELTA_ROW_COMPRESSION_H
#define _DELTA_ROW_COMPRESSION_H


#include <Debug.h>


class AbstractDeltaRowCompressor {
public:
						AbstractDeltaRowCompressor(int rowSize,
							uchar initialSeed);
	virtual				~AbstractDeltaRowCompressor();

	// InitCheck returns B_OK on successful construction of this object or
	// B_NO_MEMORY if the buffer for the seed row could not be allocated.
			status_t	InitCheck();

	// Clears the seed row to the initial seed specified in the constructor
			void		Reset();

	// Returns the size of the delta row.
	// The size is 0 if the row is equal to the seed row (previous row).
	// The seed row is updated only if updateSeedRow is true.
			int			CalculateSize(const uchar* row,
							bool updateSeedRow = false);

	// Compresses the row using the delta row compression algorithm.
	// The seed row is updated.
			void		Compress(const uchar* row);

protected:
	// append byte to delta row
	virtual	void		AppendByteToDeltaRow(uchar byte) = 0;

	// returns the current size of the delta row
	inline	int			CurrentDeltaRowSize()
						{
							return fDeltaRowIndex;
						}

private:
	// Returns the index where seed row and row differ
	// or -1 if both arrays are equal.
	inline	int			DiffersIndex(const uchar* row, int index)
						{
							while (index < fSize) {
								if (fSeedRow[index] != row[index])
									return index;
								index ++;
							}
							return -1;
						}

	// Returns the number of bytes that row differs from seed row
	// starting at the specified index.
	inline	int			DiffersLength(const uchar* row, int index)
						{
							int startIndex = index;
							while (index < fSize) {
								if (fSeedRow[index] == row[index])
									break;
								index ++;
							}
							return index - startIndex;
						}

	// Compresses row with delta row compression algorithm.
	// The seed row is updated only if updateSeedRow is true.
	// If updateDeltaRow is true the method AppendByteToDeltaRow is called.
			int 		CompressRaw(const uchar* row, bool updateSeedRow,
							bool updateDeltaRow);

	// write byte to delta row and calculate size of delta row
			void		Put(uchar byte)
						{
							if (fUpdateDeltaRow)
								AppendByteToDeltaRow(byte);
							fDeltaRowIndex ++;
						}

			uchar*		fSeedRow; // the seed row
			int			fSize; // the size of the seed row in bytes
			uchar		fInitialSeed;
							// the value to initialize the seed row with

			int			fDeltaRowIndex;
							// the index of the next byte to be written into
							// the delta row
			bool		fUpdateDeltaRow; // write delta row
};


class DeltaRowCompressor : public AbstractDeltaRowCompressor
{
public:
						DeltaRowCompressor(int rowSize, uchar initialSeed)
						:
						AbstractDeltaRowCompressor(rowSize, initialSeed)
						{}

	// The delta row to be written to.
			void		SetDeltaRow(uchar* deltaRow)
						{
							fDeltaRow = deltaRow;
						}

protected:
	virtual	void		AppendByteToDeltaRow(uchar byte)
						{
							fDeltaRow[CurrentDeltaRowSize()] = byte;
						}

private:
			uchar*		fDeltaRow; // the delta row
};

#endif