lzw压缩算法的c语言实现.txt

最短路径算法C C++ 邻接矩阵实现 哈夫曼算法和哈夫曼树 RSA算法的C++实现 lzw压缩算法的c语言实现 计算日期程序（C语言）

//------------------------------------------------------------------------------
VOID output_code( DWORD code ,PBUFFER_DATA out, PLZW_DATA lzw)
{
     out->dw_buffer |= code << ( 32 - out->by_left - lzw->cur_code_len );
     out->by_left += lzw->cur_code_len;

     while( out->by_left >= 8 )
     {
         if( out->index == BUFFERSIZE )
         {
             empty_buffer( lzw,out);
         }

         out->lp_buffer[ out->index++ ] = (BYTE)( out->dw_buffer >> 24 );
         out->dw_buffer <<= 8;
         out->by_left -= 8;
     }
}
//------------------------------------------------------------------------------
VOID do_encode( PBUFFER_DATA in, PBUFFER_DATA out, PLZW_DATA lzw)
{
     WORD prefix;
     while( in->index != in->top )
     {
         if( !in_table(lzw) )
         {
                 // current code not in code table
                 // then add it to table and output prefix


                 insert_table(lzw);
                 prefix = lzw->suffix;
                 output_code( lzw->prefix ,out ,lzw );
                 lzw->code++;

                 if( lzw->code == (WORD)1<< lzw->cur_code_len )
                 {
                     // code reached current code top(1<<cur_code_len)
                     // then current code length add one
      lzw->cur_code_len++;
      if( lzw->cur_code_len == CODE_LEN + 1 )
      {
       re_init_lzw( lzw );
      }

                 }
         }
         else
         {
                 // current code already in code table 
                 // then output nothing
                 prefix = get_code(lzw);

         }
         lzw->prefix = prefix;
         lzw->suffix = in->lp_buffer[ in->index++ ];
     }
}

//------------------------------------------------------------------------------
VOID encode(HANDLE h_sour,HANDLE h_dest)
{
     LZW_DATA         lzw;
     BUFFER_DATA      in ;
     BUFFER_DATA      out;
    
     BOOL first_run = TRUE;

     lzw_create( &lzw ,h_sour,h_dest );
     buffer_create( &in );
     buffer_create( &out );


     while( load_buffer( h_sour, &in ) )
     {
         if( first_run )
         {// File length should be considered   but here we simply 
          // believe file length bigger than 2 bytes.
                 lzw.prefix = in.lp_buffer[ in.index++ ];
                 lzw.suffix = in.lp_buffer[ in.index++ ];
                 first_run = FALSE;
         }
         do_encode(&in , &out, &lzw);
     }
    
output_code(lzw.prefix, &out , &lzw);
output_code(lzw.suffix, &out , &lzw);
out.end_flag = TRUE;
     empty_buffer( &lzw,&out);

     lzw_destory( &lzw );
     buffer_destory( &in );
     buffer_destory( &out );
}

//------------------------------------------------------------------------------

#endif

(5) decode.h   解压函数主函数

#ifndef __DECODE_H__
#define __DECODE_H__
//------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
//------------------------------------------------------------------------------
VOID out_code( WORD code ,PBUFFER_DATA buffer,PLZW_DATA lzw,PSTACK_DATA stack)
{
WORD tmp;
if( code < 0x100 )
{
   stack->lp_stack[ stack->index++ ] = code;
}
else
{
    stack->lp_stack[ stack->index++ ] = lzw->lp_suffix[ code ];
    tmp = lzw->lp_prefix[ code ];
    while( tmp > 0x100 )
    {
     stack->lp_stack[ stack->index++ ] = lzw->lp_suffix[ tmp ];
     tmp = lzw->lp_prefix[ tmp ];
    }
    stack->lp_stack[ stack->index++ ] = (BYTE)tmp;

}


while( stack->index )
{
   if( buffer->index == BUFFERSIZE )
   {
    empty_buffer(lzw,buffer);
   }
   buffer->lp_buffer[ buffer->index++ ] = stack->lp_stack[ --stack->index ] ;
}
}
//------------------------------------------------------------------------------
VOID insert_2_table(PLZW_DATA lzw )
{

lzw->lp_code[ lzw->code ]    = lzw->code;
lzw->lp_prefix[ lzw->code ] = lzw->prefix;
lzw->lp_suffix[ lzw->code ] = lzw->suffix;
lzw->code++;

if( lzw->code == ((WORD)1<<lzw->cur_code_len)-1 )
{
   lzw->cur_code_len++;
   if( lzw->cur_code_len == CODE_LEN+1 )
       lzw->cur_code_len = 9;
}
if(lzw->code >= 1<<CODE_LEN )
{
   re_init_lzw(lzw);
}

}
//------------------------------------------------------------------------------
WORD get_next_code( PBUFFER_DATA buffer , PLZW_DATA lzw )
{

BYTE next;
WORD code;
while( buffer->by_left < lzw->cur_code_len )
{
   if( buffer->index == BUFFERSIZE )
   {
    load_buffer( lzw->h_sour, buffer );
   }
   next = buffer->lp_buffer[ buffer->index++ ];
   buffer->dw_buffer |= (DWORD)next << (24-buffer->by_left);
   buffer->by_left    += 8;
}
code = buffer->dw_buffer >> ( 32 - lzw->cur_code_len );
buffer->dw_buffer <<= lzw->cur_code_len;
buffer->by_left     -= lzw->cur_code_len;

return code;
}
//------------------------------------------------------------------------------
VOID do_decode( PBUFFER_DATA in, PBUFFER_DATA out, PLZW_DATA lzw, PSTACK_DATA stack)
{
WORD code;
WORD tmp;
while( in->index != in->top   )
{
   code = get_next_code( in ,lzw );

   if( code < 0x100 )
   {
    // code already in table 
    // then simply output the code
    lzw->suffix = (BYTE)code;
   }
   else 
   {
    if( code < lzw->code   )
    {
     // code also in table 
     // then output code chain
    
     tmp = lzw->lp_prefix[ code ];
     while( tmp > 0x100 )
     {
      tmp = lzw->lp_prefix[ tmp ];
     }
     lzw->suffix = (BYTE)tmp;
    }
    else
    {
     // code == lzw->code
     // code not in table
     // add code into table
     // and out put code 
     tmp = lzw->prefix;
     while( tmp > 0x100 )
     {
      tmp = lzw->lp_prefix[ tmp ];
     }
     lzw->suffix = (BYTE)tmp;
    }
   }
   insert_2_table( lzw );
   out_code(code,out,lzw,stack);

   lzw->prefix = code;

}

}
//------------------------------------------------------------------------------
VOID decode( HANDLE h_sour, HANDLE h_dest )
{
     LZW_DATA         lzw;
     BUFFER_DATA      in ;
     BUFFER_DATA      out;
STACK_DATA       stack;
BOOL    first_run;

first_run = TRUE;


     lzw_create( &lzw ,h_sour,h_dest );
     buffer_create( &in );
     buffer_create( &out );
stack_create(&stack );

     while( load_buffer( h_sour, &in ) )
     {
   if( first_run )
   {
    lzw.prefix = get_next_code( &in, &lzw );
    lzw.suffix = lzw.prefix;
    out_code(lzw.prefix, &out, &lzw , &stack);
    first_run = FALSE;
   }
         do_decode(&in , &out, &lzw, &stack);
     }

     empty_buffer( &lzw,&out);

     lzw_destory( &lzw );
     buffer_destory( &in );
     buffer_destory( &out );
stack_destory( &stack);
}

#endif

2   下面给出一个应用上面模块的简单例子

#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------------------------------------

#include "lzw.h"
#include "hash.h"
#include "fileio.h"
#include "encode.h"
#include "decode.h"

//------------------------------------------------------------------------------
HANDLE h_file_sour;  
HANDLE h_file_dest;
HANDLE h_file;
CHAR*   file_name_in = "d:\\code.c";
CHAR*   file_name_out= "d:\\encode.e";
CHAR*   file_name     = "d:\\decode.d";


//------------------------------------------------------------------------------
int main(int argc, char *argv[]) 
{
     h_file_sour = file_handle(file_name_in);
     h_file_dest = file_handle(file_name_out);
     h_file      = file_handle(file_name);


   encode(h_file_sour, h_file_dest);  
// decode(h_file_dest,h_file); 


     CloseHandle(h_file_sour); 
     CloseHandle(h_file_dest);  
     CloseHandle(h_file);

   return 0;      
}