#ifdef _WINDOWS
#include <windows.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include "ccdef.h"
#include "compcert.h"
#include "gmem.h"
#define FIXED_MODEL 1
#define ADAPTATIVE_MODEL 2
#define Code_value_bits 16
#define No_of_chars 256
#define Max_frequency 16383
#define EOF_symbol (No_of_chars+1)
#define No_of_symbols (No_of_chars+1)
#define Top_value (( (long) 1 << Code_value_bits) - 1)
#define First_qtr (Top_value / 4 + 1)
#define Half (2 * First_qtr)
#define Third_qtr (3 * First_qtr)
typedef long code_value;
static code_value value_dc;
static code_value low_dc, high_dc;
static code_value low_enc, high_enc;
static long bits_to_follow;
static unsigned int buffer_in;
static unsigned int bits_to_go_in;
static unsigned int garbage_bits_in;
static unsigned int buffer_out;
static unsigned int bits_to_go_out;
static int Error;
unsigned int char_to_index[No_of_chars];
unsigned char index_to_char[No_of_symbols+1];
unsigned int cum_freq[No_of_symbols+1];
unsigned char *Memory;
static unsigned MemoSize;
unsigned int FixedFreqA[No_of_symbols+1] =
{
0,
63, 260, 180, 216, 254, 63, 268, 95, 43, 62, 33, 28, 14, 6, 45, 38,
33, 35, 13, 303, 41, 37, 41, 8, 15, 81, 25, 2, 15, 88, 20, 6,
/* ! = # $ % & ' ( ) * + , - . / */
662, 3, 35, 18, 12, 3, 11, 3, 16, 12, 2, 34, 42, 32, 56, 31,
/* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
300, 118, 42, 40, 21, 37, 63, 46, 10, 90, 33, 3, 1, 9, 15, 3,
/* @ A B C D E F G H I J K L M N O */
27, 158, 73, 122, 82, 31, 20, 14, 26, 56, 1, 2, 27, 20, 12, 31,
/* P Q R S T U V W X Y Z [ \ ] ^ _ */
64, 4, 65, 114, 106, 195, 10, 27, 3, 18, 25, 2, 3, 1, 2, 12,
/* ` a b c d e f g h i j k l m n o */
24, 271, 44, 171, 158, 439, 44, 50, 71, 308, 2, 5, 60, 73, 234, 280,
/* p q r s t u v w x y z { | } ~ */
76, 44, 274, 273, 358, 100, 36, 43, 12, 79, 2, 1, 1, 1, 1, 1,
48, 48, 30, 1, 1, 5, 100, 5, 1, 3, 1, 1, 1, 50, 1, 1,
1, 4, 2, 14, 1, 5, 12, 1, 4, 1, 1, 1, 1, 1, 1, 1,
6, 14, 1, 1, 24, 1, 1, 4, 1, 11, 1, 2, 23, 1, 1, 4,
1, 1, 1, 1, 5, 1, 1, 12, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 2, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1,
1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 4, 1,
1, 1, 1, 13, 12, 1, 1, 1, 1, 1, 1, 2, 1, 13, 1, 1,
5, 1, 2, 1, 12, 1, 1, 1, 24, 2, 1, 1, 1, 4, 1, 308,
250
};
unsigned int AdaptativeFreqA[No_of_symbols+1] =
{
0,
12, 24, 19, 18, 19, 6, 20, 7, 4, 5, 3, 3, 2, 2, 4, 4,
3, 4, 2, 23, 4, 4, 4, 2, 2, 7, 3, 1, 2, 7, 3, 1,
/* ! = # $ % & ' ( ) * + , - . / */
49, 1, 3, 2, 2, 2, 2, 1, 2, 2, 1, 3, 4, 3, 5, 3,
/* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
25, 9, 3, 3, 2, 3, 5, 4, 2, 7, 3, 1, 1, 1, 2, 1,
/* @ A B C D E F G H I J K L M N O */
3, 14, 6, 10, 7, 3, 3, 2, 3, 5, 1, 1, 3, 2, 1, 3,
/* P Q R S T U V W X Y Z [ \ ] ^ _ */
5, 2, 6, 9, 9, 15, 2, 3, 1, 2, 3, 2, 1, 1, 1, 2,
/* ` a b c d e f g h i j k l m n o */
2, 20, 4, 13, 12, 32, 4, 5, 6, 24, 1, 1, 5, 7, 18, 21,
/* p q r s t u v w x y z { | } ~ */
6, 4, 20, 21, 27, 8, 3, 4, 2, 7, 1, 1, 1, 1, 1, 1,
4, 9, 3, 1, 1, 1, 8, 1, 1, 3, 1, 1, 1, 5, 1, 1,
1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 1, 1, 3, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2,
1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 24,
25
};
unsigned int freq[No_of_symbols+1];
/******************************************************************************/
void start_model(int ModelType)
{
int i;
for (i = 0; i < No_of_chars; i++)
{
char_to_index[i] = i+1;
index_to_char[i+1] = (BYTE)i;
}
if (ModelType == FIXED_MODEL)
{
for (i = 0; i <= No_of_symbols; i++)
{
freq[i] = FixedFreqA[i];
}
cum_freq[No_of_symbols] = 0;
for(i = No_of_symbols; i > 0; i--)
{
cum_freq[i-1] = cum_freq[i] + freq[i];
}
}
if (ModelType == ADAPTATIVE_MODEL)
{
for (i = 0; i <= No_of_symbols; i++)
{
freq[i] = AdaptativeFreqA[i];
}
cum_freq[No_of_symbols] = 0;
for(i = No_of_symbols; i > 0; i--)
{
cum_freq[i-1] = cum_freq[i] + freq[i];
}
}
}
/******************************************************************************/
void update_model(int ModelType, unsigned int symbol)
{
unsigned int i;
unsigned int cum;
unsigned int ch_i;
unsigned int ch_symbol;
if (ModelType == ADAPTATIVE_MODEL)
{
if (cum_freq[0] == Max_frequency)
{
cum = 0;
for (i = No_of_symbols + 1; i != 0; /**/)
{
--i;
freq[i] = (freq[i] + 1) / 2;
cum_freq[i] = cum;
cum += freq[i];
}
}
for (i = symbol; freq[i] == freq[i-1]; i--)
{
}
if (i < symbol)
{
ch_i = index_to_char[i];
ch_symbol = index_to_char[symbol];
index_to_char[i] = (BYTE)ch_symbol;
index_to_char[symbol] = (BYTE)ch_i;
char_to_index[ch_i] = symbol;
char_to_index[ch_symbol] = i;
}
freq[i] += 1;
while (i > 0)
{
i -= 1;
cum_freq[i] += 1;
}
}
}
/******************************************************************************/
void start_outputing_bits(void)
{
buffer_out = 0;
bits_to_go_out = 8;
}
/******************************************************************************/
int output_bit(unsigned short int *pOutCount, unsigned int bit)
{
buffer_out >>= 1;
if (bit)
{
buffer_out |= 0x80;
}
bits_to_go_out -= 1;
if (bits_to_go_out == 0)
{
if (*pOutCount == MemoSize)
{
return RV_COMPRESSION_FAILED;
}
Memory[(*pOutCount)++] = (BYTE)buffer_out;
bits_to_go_out = 8;
}
return RV_SUCCESS;
}
/******************************************************************************/
int done_outputing_bits(unsigned short int *pOutCount)
{
if (*pOutCount == MemoSize)
{
return RV_COMPRESSION_FAILED;
}
Memory[(*pOutCount)++] = buffer_out>>bits_to_go_out;
return RV_SUCCESS;
}
/******************************************************************************/
void start_inputing_bits(void)
{
bits_to_go_in = 0;
garbage_bits_in = 0;
Error = RV_SUCCESS;
}
/******************************************************************************/
unsigned int input_bit(BLOC InBloc, unsigned short int *pusInCount)
{
unsigned int t;
if (bits_to_go_in == 0)
{
if (*pusInCount < InBloc.usLen)
{
buffer_in = InBloc.pData[(*pusInCount)++];
}
else
{
buffer_in = 0x00;
}
if (*pusInCount == InBloc.usLen)
{
garbage_bits_in += 1;
if (garbage_bits_in > Code_value_bits - 2)
{
Error = RV_INVALID_DATA;
}
}
bits_to_go_in = 8;
}
t = buffer_in & 1;
buffer_in >>= 1;
bits_to_go_in -= 1;
return (t);
}
/******************************************************************************/
int bit_plus_follow(unsigned short int *pOutCount, unsigned int bit)
{
if (output_bit(pOutCount, bit) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
while (bits_to_follow > 0)
{
if (output_bit(pOutCount, !bit) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
bits_to_follow -= 1;
}
return RV_SUCCESS;
}
/******************************************************************************/
void start_encoding(void)
{
low_enc = 0;
high_enc = Top_value;
bits_to_follow = 0;
}
/******************************************************************************/
int encode_symbol(unsigned short int *pOutCount,
unsigned int symbol,
unsigned int cum_freq[]
)
{
long range;
range = (long) (high_enc-low_enc) + 1;
high_enc = low_enc + (range * cum_freq[symbol-1]) / cum_freq[0] - 1;
low_enc = low_enc + (range * cum_freq[symbol]) / cum_freq[0];
for ( ; ; )
{
if (high_enc < Half)
{
if (bit_plus_follow(pOutCount, 0) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
}
else if (low_enc >= Half)
{
if (bit_plus_follow(pOutCount, 1) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
low_enc -= Half;
high_enc -= Half;
}
else if ((low_enc >= First_qtr) && (high_enc < Third_qtr))
{
bits_to_follow += 1;
low_enc -= First_qtr;
high_enc -= First_qtr;
}
else
{
break;
}
low_enc = 2 * low_enc;
high_enc = 2 * high_enc + 1;
}
return RV_SUCCESS;
}
/******************************************************************************/
int done_encoding(unsigned short int *pOutCount)
{
bits_to_follow += 1;
if (low_enc < First_qtr)
{
if (bit_plus_follow(pOutCount, 0) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
}
else
{
if (bit_plus_follow(pOutCount, 1) != RV_SUCCESS)
{
return RV_COMPRESSION_FAILED;
}
}
return RV_SUCCESS;
}
/******************************************************************************/
void start_decoding(BLOC InBloc, unsigned short int *pusInCount)
{
unsigned int i;
value_dc = 0;
for (i = 1; i <= Code_value_bits; i++)
{
value_dc = 2 * value_dc + input_bit(InBloc, pusInCount);
if (Error != RV_SUCCESS)
{
break;
}
}
low_dc = 0;
high_dc = Top_value;
}
/******************************************************************************/
unsigned int decode_symbol(BLOC InBloc,
unsigned short int *pusInCount,
unsigned int cum_freq[]
)
{
long range;
unsigned int cum;
unsigned int symbol;
range = (long) (high_dc-low_dc) + 1;
cum = (((long) (value_dc-low_dc) + 1) * cum_freq[0] - 1) / range;
for (symbol = 1; cum_freq[symbol] > cum; symbol++)
{
}
high_dc = low_dc + (range * cum_freq[symbol-1]) / cum_freq[0] - 1;
low_dc = low_dc + (range * cum_freq[symbol]) / cum_freq[0];
for ( ; ; )
{
if (high_dc < Half)
{
}
else if (low_dc >= Half)
{
value_dc -= Half;
low_dc -= Half;
high_dc -= Half;
}
else if ((low_dc >= First_qtr) && (high_dc < Third_qtr))
{
value_dc -= First_qtr;
low_dc -= First_qtr;
high_dc -= First_qtr;
}
else
{
break;
}
low_dc = 2 * low_dc;
high_dc = 2 * high_dc + 1;
value_dc = 2 * value_dc + input_bit(InBloc, pusInCount);
if (Error != RV_SUCCESS)
{
break;
}
}
return (symbol);
}
/******************************************************************************/
int AcAd8_Encode(BLOC *pInBloc, BLOC *pOutBloc)
{
int i, ch;
unsigned int symbol;
unsigned short int usInCount = 0;
unsigned short int usOutCount = 0;
MemoSize = pInBloc->usLen;
Memory = GMEM_Alloc (MemoSize);
if (Memory == NULL)
{
return (RV_MALLOC_FAILED);
}
start_model(ADAPTATIVE_MODEL);
start_outputing_bits();
start_encoding();
for (usInCount = 0; usInCount < pInBloc->usLen; usInCount++)
{
ch = pInBloc->pData[usInCount];
symbol = char_to_index[ch];
if (encode_symbol(&usOutCount, symbol, cum_freq) != RV_SUCCESS)
{
goto err;
}
update_model(ADAPTATIVE_MODEL, symbol);
}
if (encode_symbol(&usOutCount, EOF_symbol, cum_freq) != RV_SUCCESS)
{
goto err;
}
if (done_encoding(&usOutCount) != RV_SUCCESS)
{
goto err;
}
if (done_outputing_bits(&usOutCount) != RV_SUCCESS)
{
goto err;
}
pOutBloc->usLen = usOutCount;
pOutBloc->pData = GMEM_Alloc(pOutBloc->usLen);
if (pOutBloc->pData != NULL)
{
for (i=0; i < pOutBloc->usLen; i++)
{
pOutBloc->pData[i] = Memory[i];
}
GMEM_Free(Memory);
return (RV_SUCCESS);
}
else
{
pOutBloc->usLen = 0;
pOutBloc->pData = NULL;
GMEM_Free(Memory);
return (RV_MALLOC_FAILED);
}
err:
GMEM_Free(Memory);
pOutBloc->usLen = pInBloc->usLen;
pOutBloc->pData = GMEM_Alloc(pOutBloc->usLen);
if (pOutBloc->pData != NULL)
{
for (i=0; i < pOutBloc->usLen; i++)
{
pOutBloc->pData[i] = pInBloc->pData[i];
}
return (RV_COMPRESSION_FAILED);
}
else
{
pOutBloc->usLen = 0;
pOutBloc->pData = NULL;
return (RV_MALLOC_FAILED);
}
}
/******************************************************************************/
int AcFx8_Encode(BLOC *pInBloc, BLOC *pOutBloc)
{
int i, ch;
unsigned int symbol;
unsigned short int usInCount = 0;
unsigned short int usOutCount = 0;
MemoSize = pInBloc->usLen;
Memory = GMEM_Alloc (MemoSize);
if (Memory == NULL)
{
return (RV_MALLOC_FAILED);
}
start_model(FIXED_MODEL);
start_outputing_bits();
start_encoding();
for (usInCount = 0; usInCount < pInBloc->usLen; usInCount++)
{
ch = pInBloc->pData[usInCount];
symbol = char_to_index[ch];
if (encode_symbol(&usOutCount, symbol, cum_freq) != RV_SUCCESS)
{
goto err;
}
update_model(FIXED_MODEL, symbol);
}
if (encode_symbol(&usOutCount, EOF_symbol, cum_freq))
{
goto err;
}
if (done_encoding(&usOutCount) != RV_SUCCESS)
{
goto err;
}
if (done_outputing_bits(&usOutCount) != RV_SUCCESS)
{
goto err;
}
pOutBloc->usLen = usOutCount;
pOutBloc->pData = GMEM_Alloc(pOutBloc->usLen);
if (pOutBloc->pData != NULL)
{
for (i=0; i < pOutBloc->usLen; i++)
{
pOutBloc->pData[i] = Memory[i];
}
GMEM_Free(Memory);
return (RV_SUCCESS);
}
else
{
pOutBloc->usLen = 0;
pOutBloc->pData = NULL;
GMEM_Free(Memory);
return (RV_MALLOC_FAILED);
}
err:
GMEM_Free(Memory);
pOutBloc->usLen = pInBloc->usLen;
pOutBloc->pData = GMEM_Alloc(pOutBloc->usLen);
if (pOutBloc->pData != NULL)
{
for (i=0; i < pOutBloc->usLen; i++)
{
pOutBloc->pData[i] = pInBloc->pData[i];
}
return (RV_COMPRESSION_FAILED);
}
else
{
pOutBloc->usLen = 0;
pOutBloc->pData = NULL;
return (RV_MALLOC_FAILED);
}
}
/******************************************************************************/
int AcAd8_Decode(BLOC *pInBloc, BLOC *pOutBloc)
{
unsigned int ch;
unsigned int symbol;
unsigned short int usInCount = 0;
unsigned short int usOutCount = 0;
MemoSize = 2*pInBloc->usLen;
Memory = GMEM_Alloc(MemoSize);
if (Memory == NULL)
{
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
start_model(ADAPTATIVE_MODEL);
start_inputing_bits();
start_decoding(*pInBloc, &usInCount);
while(1)
{
symbol = decode_symbol(*pInBloc, &usInCount, cum_freq);
if ((symbol == EOF_symbol) || (Error != RV_SUCCESS))
{
break;
}
ch = index_to_char[symbol];
if (usOutCount >= MemoSize)
{
Memory = GMEM_ReAlloc (Memory, 2*MemoSize);
if (Memory == NULL)
{
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
MemoSize = MemoSize*2;
}
Memory[usOutCount++] = (BYTE)ch;
update_model(ADAPTATIVE_MODEL, symbol);
}
if (Error != RV_SUCCESS)
{
GMEM_Free (Memory);
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (Error);
}
pOutBloc->pData = GMEM_Alloc(usOutCount);
if (pOutBloc->pData == NULL)
{
GMEM_Free (Memory);
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
pOutBloc->usLen = usOutCount;
memcpy(pOutBloc->pData, Memory, usOutCount);
GMEM_Free (Memory);
return (RV_SUCCESS);
}
/******************************************************************************/
int AcFx8_Decode(BLOC *pInBloc, BLOC *pOutBloc)
{
unsigned int i, ch;
unsigned int symbol;
unsigned short int usInCount = 0;
unsigned short int usOutCount = 0;
MemoSize = 2*pInBloc->usLen;
Memory = GMEM_Alloc(MemoSize);
if (Memory == NULL)
{
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
start_model(FIXED_MODEL);
start_inputing_bits();
start_decoding(*pInBloc, &usInCount);
while(1)
{
symbol = decode_symbol(*pInBloc, &usInCount, cum_freq);
if ((symbol == EOF_symbol) || (Error != RV_SUCCESS))
{
break;
}
ch = index_to_char[symbol];
if (usOutCount >= MemoSize)
{
Memory = GMEM_ReAlloc (Memory, 2*MemoSize);
if (Memory == NULL)
{
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
MemoSize = MemoSize*2;
}
Memory[usOutCount++] = (BYTE)ch;
update_model(FIXED_MODEL, symbol);
}
if (Error != RV_SUCCESS)
{
GMEM_Free (Memory);
pOutBloc->pData = NULL;
pOutBloc->usLen = 0;
return (Error);
}
pOutBloc->pData = GMEM_Alloc(usOutCount);
if (pOutBloc->pData == NULL)
{
GMEM_Free (Memory);
pOutBloc->usLen = 0;
return (RV_MALLOC_FAILED);
}
pOutBloc->usLen = usOutCount;
for (i=0; i<pOutBloc->usLen; i++)
{
pOutBloc->pData[i] = Memory[i];
}
GMEM_Free (Memory);
return (RV_SUCCESS);
}