//void ExpandFile( BIT_FILE *input, FILE *output, int argc, char *argv[] )
void ExpandFile( BIT_FILE *input, FILE *output, int, char*[] )
{
int c;
int run_count;
int bits;
long count;
//Update so Silence and Compand do not conflict
int silence_match[6] = { 31, 0, 31, 0, 30, 0 };
int inputBuff[6];
int i;
bits = (int) InputBits( input, 8 );
count = InputBits( input, 32 );
while ( ( c = (int) InputBits( input, bits ) ) != EOF )
{
if ( c == 31 )
{
inputBuff[0] = c;
for(i = 1; i < 6; i++ )
{
inputBuff[i] = (int) InputBits( input, bits );
}
if( memcmp( &inputBuff, &silence_match, 6 ) )
{
for(i = 0; i < 6; i++ )
{
c = inputBuff[i];
putc( expand[ inputBuff[i] ], output );
}
}
else
{
run_count = (int) InputBits( input, 8 );
while ( run_count-- > 0 )
putc( 0x80, output );
}
}
else
putc( expand[ c ], output );
}
}
/*
* The expansion routine gets the number of bits per code from the
* compressed file, then builds an expansion table. Each of the
* "steps" codes expands to a unique eight-bit code that lies on
* the exponential encoding curve.
*/
void ExpandFile( BIT_FILE *input, FILE *output, int argc, char *argv[] ){
/*
BIT_FILE *input:
FILE *output;
int argc;
char *argv[];
{
*/
int steps;
int bits;
int value;
int last_value;
int i;
int c;
long count;
int expand[ 256 ];
/*
* First this routine reads in the number of bits, then it builds
* the expansion table. Once the table is built, expanding the file
* is simply a matter of performing a table lookup on each code.
*/
bits = (int) InputBits( input, 8 );
printf( "Expanding using %d bits per sample...\n", bits );
steps = ( 1 << (bits - 1 ) );
last_value = 0;
for ( i = 1; i <= steps; i++ ) {
value = 128.0 * ( pow(2.0, (double) i / steps ) - 1.0 ) + 0.5;
expand[ steps + i - 1 ] = 128 + ( value + last_value ) / 2;
expand[ steps - i ] = 127 - ( value + last_value ) / 2;
last_value = value;
}
/*
* The actual file size is stored at the start of the compressed
* file. It is read in to determine how many codes need to be
* expanded. Once that is done, expansion takes place rapidly.
*/
for ( count = InputBits( input, 32 ); count > 0 ; count-- ) {
c = (int) InputBits( input, bits );
putc(expand[ c ], output );
}
while ( argc-- > 0 )
printf( "Unused argument: %s\n", *argv++ ) ;
}
void CharCount(char *argv)
{
int i, sum=0;
unsigned long byte;
BIT_FILE *input_file;
//get pointers of the input file and output file by argument from command line
input_file = OpenInputBitFile(argv);
//initialize symboy counter array symbo[NUM]
memset(symbol, 0, sizeof(int)*NUM);
while (1) {
byte = InputBits(input_file, 8);
symbol[byte]++;
if (byte == 256) {
break;
}
}
for (i=0; i<NUM; i++) {
sum += symbol[i];
}
printf("total weight: %d\n", sum);
}
/*
*-------------------------------------------------------------------------------
* 3.1 LZSS_ExpandData
*-------------------------------------------------------------------------------
*
* LZSS expand data stream
*
* This routine expands data from an in buffer with the LZSS algorithm.
* The routine read in flag bits to decide whether to read in an uncompressed
* character or an index/length pair and expands the data stream to an out
* buffer.
*
* param inBuf Input data buffer with bit access
* param outBuf Output data buffer with byte access
*
* return Void
*
*/
void LZSS_ExpandData(LZSS_InputBuffer_T *inBuf, LZSS_OutputBuffer_T *outBuf)
{
/** Index var. for loop */
Uint8_T i = 0;
/** Current window position */
Uint16_T winPos = 1;
/** Byte to write to output buffer */
Uint8_T outByte = 0;
/** Length of the data match found */
Uint8_T matchLen = 0;
/** Position in the window of the data match */
Uint16_T matchPos = 0;
/** Indicator of End Of Stream reached */
BOOL_T eosReached = FALSE;
while (!eosReached)
{
/* If next bit is 1, next byte is uncompressed*/
if (InputBit(inBuf) == 1)
{
/* Get uncompressed byte */
outByte = (Uint8_T)InputBits(inBuf, (Uint8_T)8);
/* Output byte*/
OutputByte(outByte, outBuf);
/* Add byte in window */
LZSS_window[winPos] = outByte;
/* Increase window position */
winPos = LZSS_MOD_WINDOW(winPos + 1);
}
/* If next bit is 0, compressed data follows */
else
{
/* Get compressed data as window position of match*/
matchPos = (Uint16_T)InputBits(inBuf, LZSS_INDEX_BIT_COUNT);
/* If end of stream, exit */
if (matchPos == LZSS_END_OF_STREAM)
{
eosReached = TRUE;
}
else
{
/* Get length of string match */
matchLen = (Uint8_T)InputBits(inBuf, LZSS_LENGTH_BIT_COUNT);
/* Add break even + 1 to get the correct length. Length zero and
* the break even value are subtracted from the length during
* compression to save space. */
matchLen = matchLen + (LZSS_BREAK_EVEN + 1);
/* For every byte in match */
for (i = 0; i < matchLen; i++)
{
/* Get matching byte from window */
outByte = LZSS_window[LZSS_MOD_WINDOW(matchPos + i)];
/* Output byte */
OutputByte(outByte, outBuf);
/* Add matched byte to current window position */
LZSS_window[winPos] = outByte;
/* Increase window position */
winPos = LZSS_MOD_WINDOW(winPos + 1);
}
}
}
}
}
* The file expander operates much like the encoder. It has to
* read in codes, the convert the codes to a string of characters.
* The only catch in the whole operation occurs when the encoder
* encounters a CHAR+STRING+CHAR+STRING+CHAR sequence. When this
* occurs, the encoder outputs a code that is not presently defined
* in the table. This is handled as an exception.
*/
QUICK_EXPAND(lzw12)
unsigned int next_code;
unsigned int new_code;
unsigned int old_code;
int character;
unsigned int count;
next_code = FIRST_CODE;
old_code = (unsigned int) InputBits( input, BITS );
if ( old_code == END_OF_STREAM )
goto quit;
character = old_code;
mn_putc( old_code, &output );
while ( ( new_code = (unsigned int) InputBits( input, BITS ) )
!= END_OF_STREAM ) {
/*
** This code checks for the CHARACTER+STRING+CHARACTER+STRING+CHARACTER
** case which generates an undefined code. It handles it by decoding
** the last code, and adding a single character to the end of the decode string.
*/
if ( new_code >= next_code ) {
decode_stack[ 0 ] = (char) character;
count = lzw12_decode_string( 1, old_code );
ubyte *lzw_expand( ubyte *inputbuf, ubyte *outputbuf, int length )
{
BIT_BUF *input;
unsigned int new_code;
unsigned int old_code;
int character;
unsigned int count;
int counter;
input = OpenInputBitBuf( inputbuf );
if ( outputbuf == NULL )
outputbuf = (ubyte *)malloc(length*sizeof(ubyte));
InitializeStorage();
counter = 0;
for ( ; ; )
{
InitializeDictionary();
old_code = (unsigned int) InputBits( input, current_code_bits );
if ( old_code == END_OF_STREAM )
{
CloseInputBitBuf( input );
return outputbuf;
}
character = old_code;
if (counter<length)
{
outputbuf[counter++] = ( ubyte ) old_code;
}
else
{
//printf( "ERROR:Tried to write %d\n", old_code );
//exit(1);
return 0;
}
for ( ; ; )
{
new_code = (unsigned int) InputBits( input, current_code_bits );
if ( new_code == END_OF_STREAM )
{
CloseInputBitBuf( input );
FreeStorage();
return outputbuf;
}
if ( new_code == FLUSH_CODE )
break;
if ( new_code == BUMP_CODE )
{
current_code_bits++;
continue;
}
if ( new_code >= next_code )
{
decode_stack[ 0 ] = (char) character;
count = decode_string( 1, old_code );
}
else
{
count = decode_string( 0, new_code );
}
character = decode_stack[ count - 1 ];
while ( count > 0 ) {
// This lets the case counter==length pass through.
// This is a hack.
if (counter<length) {
//printf("%x ", ( ubyte ) decode_stack[ count ]);
outputbuf[counter++] = ( ubyte ) decode_stack[ --count ];
} else if (counter>length) {
printf( "ERROR:Tried to write %d\n", decode_stack[ --count ] );
exit(1);
} else
count--;
}
dict[ next_code ].parent_code = old_code;
dict[ next_code ].character = (char) character;
next_code++;
old_code = new_code;
}
}
}
