LZW紧缩类完成无损紧缩比竟然到了可耻的4:1

一番蛋疼的调试修正总算作业正常

#include “stdafx.h”
//CLZW类完成
#include “LZW.h”

//富丽的分割线——————————————————–
//创立目标时初始化数据
CLZW::CLZW()
{
hash_code=0;
hash_prefix=0;
hash_suffix=0;
symbol_head=0;
symbol_tail=0;
symbol_stack=0;
}

//富丽的分割线——————————————————–
CLZW::~CLZW()
//毁掉目标时开释内存
{
if(hash_code) free(hash_code);
if(hash_prefix) free(hash_prefix);
if(hash_suffix) free(hash_prefix);
if(symbol_head) free(symbol_head);
if(symbol_tail) free(symbol_tail);
if(symbol_stack) free(symbol_stack);
}

//富丽的分割线——————————————————–
int CLZW::GetDataBlock(char *buf)
//零长度块标志数据块完毕
{
int count;
if ((count=getc(infile))!=EOF)
{
if(count>0)
{
if(fread(buf,1,count,infile)!=(size_t)count)
{
return -1;
}
}
}
return count;
}

//富丽的分割线——————————————————–
void CLZW::SkipDataBlocks()
//找到数据块结束
{
char buf[256];
while (GetDataBlock(buf)>0);
}

//富丽的分割线——————————————————–
void CLZW::ReInitLZW()
//初始化LZW状况
{
n_bits=init_bits;
maxcode=ClearCode<<1;
code_counter=ClearCode+2;//榜首个未用的代码值
sp=symbol_stack;//初始化栈使其为空
}

//富丽的分割线——————————————————–
void CLZW::InitLZWCode(FILE* file,int ibits)
{
//GetCode初始化分配内存
symbol_head=(code_int*)malloc(LZW_TABLE_SIZE*sizeof(code_int));
symbol_tail=(UINT_8*)malloc(LZW_TABLE_SIZE*sizeof(UINT_8));
symbol_stack=(UINT_8*)malloc(LZW_TABLE_SIZE*sizeof(UINT_8));
infile=file;
init_bits=ibits;
last_byte=2;//确保从头仿制最终两个字节
last_bit=0;//缓冲区为空
cur_bits=0;//缓冲区的榜首个字符
out_of_blocks=false;
//LZWReadByte 初始化
ClearCode=((code_int)1<<(init_bits-1));
EOFCode=ClearCode+1;
first_byte=true;
ReInitLZW();

}

//富丽的分割线——————————————————–
int CLZW::GetCode()
//从紧缩数据中提取今后的code_size个比特
{
int offs,ret,count;
if((cur_bits+n_bits)>last_bit)
{
//从头装 载缓冲区
if(out_of_blocks)
{
return EOFCode;
}
//坚持最终两个字节
code_buf[0]=code_buf[last_byte-2];
code_buf[1]=code_buf[last_byte-1];
//装载更多的字节如抵达结束设置标志
if((count=GetDataBlock(&code_buf[2]))==0)
{
out_of_blocks=true;
return EOFCode;
}
//重置计数器
cur_bits=(cur_bits-last_bit)+16;
last_byte=2+count;
last_bit=last_byte*8;
}
//构成堆集下一个24位的字符
offs=cur_bits>>3;
cur_accum=code_buf[offs+2]&0xFF;
cur_accum<<=8;
cur_accum|=code_buf[offs+1]&0xFF;
cur_accum<<=8;
cur_accum|=code_buf[offs]&0xFF;
//向右堆集摆放cur_bit然后经过掩码得到需求的bits数
cur_accum>>=(cur_bits&7);
ret=((int)cur_accum)&((1<cur_bits+=n_bits;
return ret;
}

//富丽的分割线——————————————————–
int CLZW::LzwReadByte()
{
static int oldcode;//前一个LZW符
static int firstcode;//原码扩展后的榜首个字节
register int code;//当前作业代码
int incode;//保存实践的输入代码

if(first_byte)
{
first_byte=false;
code=ClearCode;
}else{
//假如栈有曾经读过的符号回来它
if(sp>symbol_stack)return (int)*(–sp);
//读入新的符号
code=GetCode();
}

if(code==ClearCode)
{
ReInitLZW();
do{
code=GetCode();
}while (code==ClearCode);
if(code>ClearCode){
//确保它是一个未紧缩的字节
code=0;
}
firstcode=oldcode=code;
return code;
}
if(code==EOFCode)
{
if(!out_of_blocks)
{
SkipDataBlocks();
out_of_blocks=true;
}
//没有满足的数据
return 257;
}

//得到正常未紧缩的字节或LZW符号
incode=code;
if(code>=code_counter)
{
if(code>code_counter)
{
//避免在符号表中发生循环
incode=0;
}
*sp++=(UINT_8) firstcode;
code=oldcode;
}

//假如是一个符号把它扩展后放入栈
while (code>=ClearCode)
{
//符号头：一个字节符
*sp++=symbol_tail[code];
//符号尾：另一个LZW符号
code=symbol_head[code];

}

//表明是一个未被紧缩的字节
firstcode=code;

//判别表中是否有空间
if((code=code_counter){
//界说一个新的符号=本来的符号+这个符号扩展后的头字节
symbol_head[code]=oldcode;
symbol_tail[code]=(UINT_8) firstcode;
code_counter++;

//添加n_bits
if((code_counter>=maxcode)&&(n_bits{
n_bits++;
maxcode<<=1;
}
}