// Created:09-25-98
// By Jeff Connelly

// RLE type 2 compression

// Based on both ORIGSRC\CODRLE2.C and ORIGSRC\DCODRLE2.C written by
// David Bourgin

#include "stdafx.h"
#define EXPORTING
#include "comprlib.h"
#include "rle2.h"

#include <string.h>

static void rle2write_rep(unsigned char header_byte,
                          unsigned char repeated_byte,
                          unsigned int repetition_number)
{
    if (repetition_number < 4)
        if (repeated_byte == header_byte)
        {
            write_byte(header_byte);
            write_byte(repetition_number - 1);
        }
        else
        {
            register unsigned int i;
            for (i = 1; i <= repetition_number; i++)
                write_byte(repeated_byte);
        }
    else
    {
        write_byte(header_byte);
        write_byte(repetition_number - 1);
        write_byte(repeated_byte);
    }
}

static void rle2write_non_rep(unsigned char header_byte,
                              unsigned char non_repeated_byte)
{
    if (non_repeated_byte == header_byte)
    {
        write_byte(header_byte);
        write_byte(0);
    }
    else
        write_byte(non_repeated_byte);
}

void EXPORT rle2_encode ()
{
    unsigned char byte1, byte2, header_byte;
    unsigned int frame_size;
    register unsigned int i;
    unsigned long int lookup_table[256];

    if (!end_of_data())
    {
        (void)memset((char*)lookup_table, 0, sizeof(lookup_table));
        while (!end_of_data())
        {
            byte1 = read_byte();
            ++lookup_table[byte1];
        }
        header_byte = 0;
        for (i = 1; i <= 255; i++)
            if (lookup_table[i] < lookup_table[header_byte])
                header_byte = i;
        write_byte(header_byte);
        beginning_of_data();            // New data analysis
        byte1 = read_byte();
        frame_size = 1;
        if (!end_of_data())
        {
            byte2 = read_byte();
            frame_size = 2;
            do                          // Beginning of compression
            {
                if (byte1 == byte2)
                {
                    while (!end_of_data() && (byte1 == byte2) &&
                           frame_size < 256)
                    {
                        byte2 = read_byte();
                        ++frame_size;
                    }
                if (byte1 == byte2)
                {
                    rle2write_rep(header_byte, byte1, frame_size);
                    if (!end_of_data())
                    {
                        byte1 = read_byte();
                        frame_size = 1;
                    } else
                        frame_size = 0;
                    } else {
                        rle2write_rep(header_byte, byte1, frame_size - 1);
                        byte1 = byte2;
                        frame_size = 1;
                    }
                } else {
                rle2write_non_rep(header_byte, byte1);
                byte1 = byte2;
                frame_size = 1;
            }
            if (!end_of_data())
            {
                byte2 = read_byte();
                frame_size = 2;
            }
        }
        while (!end_of_data() || (frame_size >= 2));
    }
    if (frame_size == 1)        // Is there an extra last byte?
        rle2write_non_rep (header_byte, byte1);
    }
}

// Decompression of RLE 2
void EXPORT rle2_decode ()
{
    unsigned char header_byte, byte_read, byte_to_repeat;
    register unsigned int i;
    if (!end_of_data())
    {
        header_byte = read_byte();
        do
        {
            if ((byte_read = read_byte()) == header_byte)
            {
                byte_read = read_byte();
                if (byte_read < 3)
                    byte_to_repeat = header_byte;
                else
                    byte_to_repeat = read_byte();
                for (i = 0; i <= byte_read; i++)
                    write_byte(byte_to_repeat);
            } else
                write_byte(byte_read);
        }
        while (!end_of_data())
            ;
    }
}