开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
CHCODE.H
资源名称：huff_stream.zip　[点击查看]
上传用户：zdlsnail
上传日期：2007-01-06
资源大小：16k
文件大小：14k
源码类别：

压缩解压

开发平台：

Visual C++

CHCODE.H：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #define BITS            15
  6. #define MAX_CODE        ( ( 1<<BITS )-1 )
  7. #define TABLE_SIZE      35023l
  8. #define TABLE_BANKS     ( ( TABLE_SIZE>>8 )+1 )
  9. #define END_OF_STREAM   256
  10. #define BUMP_CODE       257
  11. #define FLUSH_CODE      258
  12. #define FIRST_CODE      259
  13. #define UNUSED          -1
  14. #define PACIFIER_COUNT  2047
  16. /*long  array[128]={6,33,34,35,36,37,38,39,5,41,42,43,44,45,46,47,
  17. // 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,7,65,66,67,
  18. // 68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
  19. // 88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,
  20. // 106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,
  21. // 121,122,123,124,125,126,127,3,129,130,131,132,133,134,4,
  22. // 136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,
  23. // 151,152,153,154,155,156,157,158,159};
  24. */long  array[64]={48,49,50,51,52,53,54,55,56,57,
  25.                     65,66,67,68,69,70,71,72,73,74,75,76,
  26.                     77,78,79,80,81,82,83,84,85,86,87,88,89,90,
  27.                     97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,
  28.                     117,118,119,120,121,122,40,41};
  31. struct dictionary{
  32.    long  code_value;
  33.    long  parent_code;
  34.    char character;
  35.    } * dict[TABLE_BANKS];
  37. typedef struct bit_stream{
  38.   unsigned char mask;
  39.   long  rack;
  40.   long  pacifier_counter;
  41.   }BIT_STREAM;
  43. void InitializeDictionary();
  44. void InitializeStorage();
  45. unsigned long  find_child_node( long  parent_code,long  child_character );
  46. unsigned long  decode_string( unsigned long  offset,unsigned long  code );
  48. void OutputBits( BIT_STREAM * bit_stream,
  49.                  unsigned long code,
  50.                  long  count,
  51.                  unsigned char * outstream,
  52.                  long * flag );
  53. unsigned long InputBits( BIT_STREAM  * bit_stream,
  54.                          long bit_count,
  55.  unsigned char * instream,
  56.  long length,
  57.                          long * flag );
  59. long code( unsigned char * instream,long length,unsigned char * outstream );
  60. long uncode( unsigned char * instream,long length,unsigned char * outstream );
  62. BIT_STREAM * OpenOutputBitStream( void );
  63. BIT_STREAM * OpenInputBitStream( void );
  65. void CompressStream( BIT_STREAM * output,
  66.    unsigned char * instream,
  67.    long length,
  68.    unsigned char * outstream ,
  69.                    long * flag);
  70. long ExpandStream( BIT_STREAM * input,
  71.                    unsigned char * instream,
  72.                    long length,
  73.                    unsigned char * outstream);
  74. long compress_code( unsigned char * instream,long length );
  75. long uncode_expand( unsigned char * instream,long length );
  77. #define DICT(i) dict[i>>8][i&0xff]
  79. char decode_stack[TABLE_SIZE];
  80. unsigned long  next_code;
  81. long  current_code_bits;
  82. unsigned long  next_bump_code;
  85. long compress_code( unsigned char * instream,long length )
  86. {
  87.   BIT_STREAM * output;
  88.   unsigned char * outstream,* copy_outstream;
  89.   unsigned char * mediastream,* copy_mediastream;
  90.   long * flag,i;
  91.   if(length==0) return(length);  
  92.   outstream=(unsigned char *)malloc(2*length+1);
  93.   copy_outstream=outstream;
  94.   mediastream=(unsigned char *)malloc(2*length);
  95.   copy_mediastream=mediastream;
  96.   flag=(long *)malloc(8);
  97.   *flag=0;
  98.   setbuf( stdout,NULL );
  99.   output=OpenOutputBitStream();
  100.   CompressStream( output,instream,length,outstream,flag );
  101.   for( i=1l;i<=*flag;i++ )  * mediastream++=*outstream++;
  102.   mediastream-=*flag;
  103.   outstream-=*flag;
  104.   length=code( mediastream,*flag,outstream );
  105.   for( i=1l;i<=length;i++ ) *instream++=*outstream++;
  106.   *instream='';
  107.   instream-=length;
  108.   outstream-=length;
  109.   free((unsigned char *)copy_outstream);
  110.   free((unsigned char *)copy_mediastream);
  111.   free((long *)flag);
  112.   free((BIT_STREAM *)output);
  113.   return(length);
  114. }
  116. void InitializeDictionary()
  117. {
  118.   unsigned long  i;
  120.   for( i=0;i<TABLE_SIZE;i++ )
  121.        DICT(i).code_value=UNUSED;
  122.   next_code=FIRST_CODE;
  123.   current_code_bits=9;
  124.   next_bump_code=511;
  125. }
  127. void InitializeStorage()
  128. {
  129.   long  i;
  131.   for( i=0;i<TABLE_BANKS;i++ )
  132.        dict[i]=( struct dictionary * )calloc( 256,sizeof( struct dictionary ) );
  133.   return;
  134. }
  136. void CompressStream( BIT_STREAM * output,
  137.                      unsigned char * instream,
  138.                      long length,
  139.                      unsigned char * outstream,
  140.                      long * flag)
  141. {
  142.   long  character;
  143.   long  string_code;
  144.   unsigned long  index;
  145.   long i,j,k;
  148.   InitializeStorage();
  149.   InitializeDictionary();
  150.   string_code=*instream; instream++;
  151.   for( i=1l;i<=(length+1);i++ ){
  152.          character= * instream;
  153.          if(i==length) character=13;
  154.          if(i==(length+1)) character=10;
  155.          instream++;
  156.          index=find_child_node( string_code,character );
  157.          if( DICT( index ).code_value!=-1 )
  158.              string_code=DICT( index ).code_value;
  159.           else {
  160.              DICT( index ).code_value=next_code++;
  161.              DICT( index ).parent_code=string_code;
  162.              DICT( index ).character=( char )character;
  163.              j=*flag;
  164.              OutputBits( output,( unsigned long )string_code,
  165.                          current_code_bits,outstream,flag );
  166.              for( k=1l;k<=(*flag-j);k++ ) *outstream++;
  167.              string_code=character;
  168.              if( next_code>MAX_CODE ) {
  169.                  j=*flag;
  170.                  OutputBits( output,( unsigned long )FLUSH_CODE,
  171.                              current_code_bits,outstream,flag );
  172.                  for( k=1l;k<=(*flag-j);k++ ) *outstream++;
  173.                  InitializeDictionary();
  174.                }
  175.              else if( next_code>next_bump_code ){
  176.                       j=*flag;
  177.                       OutputBits( output,( unsigned long )BUMP_CODE,
  178.                                   current_code_bits,outstream,flag);
  179.                       for( k=1l;k<=(*flag-j);k++ ) *outstream++;
  180.                       current_code_bits++;
  181.                       next_bump_code<<=1;
  182.                       next_bump_code|=1;
  184.                   }
  185.                }
  186.               }
  187.   j=*flag;
  188.   OutputBits( output,( unsigned long )string_code,
  189.               current_code_bits,outstream,flag );
  190.   for( k=1l;k<=(*flag-j);k++ ) *outstream++;
  191.   OutputBits( output,( unsigned long )END_OF_STREAM,
  192.               current_code_bits,outstream,flag );
  193.   for( k=0;k<TABLE_BANKS;k++ )
  194.       free( (struct dictionary *) dict[k] );
  195. }
  197. unsigned long  find_child_node( long  parent_code,long  child_character )
  198. {
  199.   unsigned long  index;
  200.   long  offset;
  202.   index=( child_character<<( BITS-8 ) )^parent_code;
  203.   if( index==0 )
  204.       offset=1;
  205.   else
  206.       offset=TABLE_SIZE-index;
  207.   for( ; ; ) {
  208.        if( DICT( index ).code_value==UNUSED )
  209.            return( ( unsigned long  )index );
  210.        if( DICT( index ).parent_code==parent_code &&
  211.            DICT( index ).character==( char )child_character )
  212.            return( index );
  213.        if( ( long  )index>=offset )
  214.            index-=offset;
  215.        else
  216.            index+=TABLE_SIZE-offset;
  217.        }
  218. }
  221. unsigned long  decode_string( unsigned long  count,unsigned long  code )
  222. {
  223.   while( code>256 ){
  224.          decode_stack[count++]=DICT( code ).character;
  225.          code=DICT( code ).parent_code;
  226.          }
  227.   decode_stack[count++]=( char )code;
  228.   return( count );
  229. }
  231. void OutputBits( BIT_STREAM * bit_stream,unsigned long code,long  count,
  232.                  unsigned char * outstream,long * flag )
  233. {
  234.   unsigned long mask;
  236.   mask=1l<<( count-1 );
  237.   while( mask!=0 ) {
  238.      if( mask & code )
  239.          bit_stream->rack|=bit_stream->mask;
  240.      bit_stream->mask>>=1;
  241.      if( bit_stream->mask==0 )  {
  242.           * outstream=(unsigned char)(bit_stream->rack);
  243.   (*flag)++;
  244.           outstream++;
  245.           if( ( bit_stream->pacifier_counter++ & PACIFIER_COUNT )==0 );
  247.          bit_stream->rack=0;
  248.          bit_stream->mask=0x80;
  249.         }
  250.      mask >>= 1;
  251.   }
  252. }
  255. BIT_STREAM * OpenOutputBitStream( )
  256. {
  257.   BIT_STREAM * bit_stream;
  259.   bit_stream=( BIT_STREAM * )calloc( 1,sizeof( BIT_STREAM ) );
  260.   if( bit_stream==NULL )
  261.     return( bit_stream );
  262.   bit_stream->rack=0;
  263.   bit_stream->mask=0x80;
  264.   bit_stream->pacifier_counter=0;
  265.   return( bit_stream );
  266. }
  268. long  code( unsigned char * mediastream,
  269.            long length,unsigned char * outstream )
  270. {
  272.   unsigned char rackin,rackout,out_char;
  273.   long  i,j,flag;
  274.   short mask;
  275.   long number;
  276.   unsigned char bit[8];
  279.   if( length/3*3==length ) number=length*8/6;
  280.   else number=(length*8/6+1);
  281.   flag=2;
  282.   for( i=1l;i<=number;i++ ){
  283.           if( flag==10 ) flag=2;
  284.   mask=0x01;
  285.           rackout=0;
  286.           if( (flag==8)||(i==number) ) rackin=0;
  287.           else{ rackin=* mediastream;
  288.                 mediastream++; }
  289.   rackout=(rackin>>flag);
  290.           for( j=(9-flag);j<=6;j++ )
  291.                rackout |= bit[j];
  292.           out_char=(unsigned char)(array[rackout]);
  293.           *outstream++=out_char;
  294.           for( j=(7-flag);j<=6;j++ ){
  295.                bit[j]=rackin & mask;
  296.                bit[j]<<=(6-flag);
  297.        mask<<=1;}
  298.           flag+=2;
  299.          }
  300.   return( number );
  301. }
  303. long uncode_expand( unsigned char * instream,long length )
  304. {
  305.   BIT_STREAM * input;
  306.   unsigned char * outstream,* copy_outstream;
  307.   unsigned char * mediastream,* copy_mediastream;
  308.   long i;
  309.   if(length==0) return(length);  
  310.   outstream=(unsigned char *)malloc(4*length);
  311.   copy_outstream=outstream;
  312.   mediastream=(unsigned char *)malloc(2*length);
  313.   copy_mediastream=mediastream;
  314.   setbuf( stdout,NULL );
  315.   input=OpenInputBitStream( );
  316.   length=uncode( instream,length,outstream);
  317.   for( i=1l;i<=length;i++ ) *mediastream++=*outstream++;
  318.   mediastream-=length;
  319.   outstream-=length;
  320.   length=ExpandStream( input,mediastream,length,outstream);
  321.   for( i=1l;i<=length;i++ ) *instream++=*outstream++;
  322.   *instream='';
  323.   instream-=length;
  324.   outstream-=length;
  325.   free((unsigned char *)copy_outstream );
  326.   free((unsigned char *)copy_mediastream);
  327.   free((BIT_STREAM *)input);
  328.   return( length-2);
  329. }
  332. long ExpandStream( BIT_STREAM * input,unsigned char * instream,long length,
  333.                    unsigned char * outstream )
  334. {
  335.   unsigned long new_code;
  336.   unsigned long old_code;
  337.   long character;
  338.   unsigned long count;
  339.   long k,j,ff=0;
  340.   long * flag;
  342.   flag=(long *)malloc(sizeof(long));
  343.   *flag=0l;
  344.   InitializeStorage();
  345.   for( ; ; ) {
  346.         InitializeDictionary();
  347.         k=*flag;
  348.         old_code=( unsigned long )InputBits( input,current_code_bits,
  349.                                  instream,length,flag );
  350.         for( j=1l;j<=(*flag-k);j++ ) instream++;
  351.         /*************/
  352.         if( old_code==(unsigned long)(length|0x10000000) )  return( ff );
  353.         /*************/
  354.         if( old_code==END_OF_STREAM )
  355.             { instream-=*flag;free((long*)flag); return( ff );}
  356.         character=old_code;
  357.         *outstream++=(unsigned char)(character);ff++;
  358.         for( ; ; ) {
  359.              k=*flag;
  360.              new_code=( unsigned long )InputBits( input,current_code_bits ,
  361.                                          instream,length,flag );
  362.              for( j=1l;j<=(*flag-k);j++ ) instream++;
  363.         /*************/
  364.         if( new_code==(unsigned long)(length|0x10000000) )
  365.    { return(ff);}
  366.         /*************/
  367.         if( new_code==END_OF_STREAM )
  368.             { instream-=*flag;free((long *)flag); return( ff );}
  369.         if( new_code==FLUSH_CODE )
  370.             break;
  371.         if( new_code==BUMP_CODE ) {
  372.             current_code_bits++;
  373.             continue;
  374.         }
  375.         if( new_code>=next_code ) {
  376.             decode_stack[0]=( char )character;
  377.             count=decode_string( 1,old_code );
  378.             }
  379.         else
  380.             count=decode_string( 0,new_code );
  381.         character=decode_stack[count-1];
  382.         while( count>0 )
  383.              {  * outstream++=decode_stack[--count];ff++;}
  385.         DICT( next_code ).parent_code=old_code;
  386.         DICT( next_code ).character=( char )character;
  387.         next_code++;
  388.         old_code=new_code;
  389.         }
  390.      }
  391. }
  394. unsigned long InputBits( BIT_STREAM * bit_stream,long bit_count,
  395.  unsigned char * instream,long length,long * flag )
  396. {
  397.   unsigned long mask;
  398.   unsigned long return_value;
  400.   mask=1l<<( bit_count-1 );
  401.   return_value=0;
  402.   while( mask!=0 ) {
  403.      if( bit_stream->mask==0x80 ) {
  404.          bit_stream->rack=* instream++; (*flag)++;
  405.          /****************/
  406.          if( *flag==length ) return( length|0x10000000 );
  407.          /****************/
  408.          if( ( bit_stream->pacifier_counter++ & PACIFIER_COUNT )==0 );
  409.          }
  410.      if( bit_stream->rack & bit_stream->mask )
  411.          return_value|=mask;
  412.      mask>>=1;
  413.      bit_stream->mask>>=1;
  414.      if( bit_stream->mask==0 )
  415.          bit_stream->mask=0x80;
  416.    }
  417.   return( return_value );
  418. }
  420. BIT_STREAM * OpenInputBitStream( )
  421. {
  422.   BIT_STREAM * bit_stream;
  424.   bit_stream=( BIT_STREAM * )calloc( 1,sizeof( BIT_STREAM ) );
  425.   if( bit_stream==NULL )
  426.     return( bit_stream );
  427.   bit_stream->rack=0;
  428.   bit_stream->mask=0x80;
  429.   bit_stream->pacifier_counter=0;
  430.   return( bit_stream );
  431. }
  433. long uncode( unsigned char * instream,long length,unsigned char * outstream )
  434. {
  435.   unsigned char rackin;
  436.   unsigned char rackout;
  437.   short mask;
  438.   long j,flag;
  439.   unsigned char bit[8];
  440.   long i,k=0;
  441.   
  442.   for( i=1l;i<=length;i++ ){
  443.        rackin=* instream++;
  444.        for( j=0;j<=63;j++ )
  445.     if( array[j]==rackin )  break;
  446.        rackin=(unsigned char)(j);
  447.        rackout=( rackin<<2 ) ;
  448.        for( flag=1;flag<=5;flag+=2 ){
  449.             mask=0x20;
  450.     rackin=*instream++;
  451.             i++;if(i>length) break;
  452.             for( j=0;j<=63;j++ )
  453.  if( array[j]==rackin ) break;
  454.             rackin=(unsigned char)(j);
  455.             for( j=flag;j>=0;j-- ){
  456.                  bit[j]=rackin & mask;
  457.                  bit[j]>>=(5-flag);
  458.                  rackout |= bit[j];
  459.                  mask>>=1;
  460.                  }
  461.        
  462.        *outstream++=rackout; k++;
  463.        rackout=( rackin<<(flag+3) );
  464.        }
  465.   }
  466.   * outstream++=0xfe;k+=1;
  467.   return( k );
  468. }