huffuman_encoding.txt

哈夫曼编码是消除编码冗余最常用的方法

/////////////////////////////////////////////


#include <stdio.h>
#include <stdlib.h>
short           father[512];
unsigned short  code[256], heap_length;
unsigned long   compress_charcount, file_size, heap[257];
unsigned char   code_length[256];
long            frequency_count[512];

FILE            *ifile, *ofile;

void reheap(unsigned short heap_entry);
/**************************************************************************
 COMPRESS_IMAGE ()
 This function performs the actual data compression.
 **************************************************************************/

void compress_image ()
{
   register unsigned int    thebyte = 0;
   register short           loop1;
   register unsigned short  current_code;
   register unsigned long   loop;

   unsigned short  current_length, dvalue;
   unsigned long   curbyte = 0;
   short           curbit = 7;


   for (loop = 0L; loop < file_size; loop++)
   {
      dvalue         = (unsigned short) getc (ifile);
      current_code   = code[dvalue];
      current_length = (unsigned short) code_length[dvalue];

      for (loop1 = current_length-1; loop1 >= 0; --loop1)
      {
         if ((current_code >> loop1) & 1)
            thebyte |= (char) (1 << curbit);

         if (--curbit < 0)
         {
            putc (thebyte, ofile);
            thebyte = 0;
            curbyte++;
            curbit = 7;
         }
      }
   }
   putc (thebyte, ofile);
   compress_charcount = ++curbyte;
}


/**************************************************************************
 COMPRESSION_REPORT ()
 This function displays the results of the compression sequence.
 **************************************************************************/

void  compression_report ()
{
   float           savings;
   unsigned short  header_charcount;
   unsigned long   output_characters;
   header_charcount   = 768 + sizeof (file_size);
   output_characters  = (unsigned long) header_charcount +
			compress_charcount;
   savings = 100 - ((float) output_characters / (float) file_size) * 100;
 }

/**************************************************************************
 GENERATE_CODE_TABLE ()
 This function generates the compression code table.
 **************************************************************************/

unsigned short  generate_code_table ()
{
   register unsigned short  loop;
   register unsigned short  current_length;
   register unsigned short  current_bit;

   unsigned short  bitcode;
   short           parent;


   for (loop = 0; loop < 256; loop++)
      if (frequency_count[loop])
      {
         current_length = bitcode = 0;
         current_bit = 1;
         parent = father[loop];

         while (parent)
         {
            if (parent < 0)
            {
               bitcode += current_bit;
               parent = -parent;
            }
            parent = father[parent];
            current_bit <<= 1;
            current_length++;
         }

         code[loop] = bitcode;

         if (current_length > 16)
            return (0);
         else
            code_length[loop] = (unsigned char) current_length;
      }
      else
         code[loop] = code_length[loop] = 0;

   return (1);
}
/**************************************************************************
 BUILD_CODE_TREE ()
 This function builds the compression code tree.
 **************************************************************************/

void build_code_tree ()
{
   register unsigned short  findex;
   register unsigned long   heap_value;
   while (heap_length != 1)
   {
      heap_value = heap[1];
      heap[1]    = heap[heap_length--];

      reheap (1);
      findex = heap_length + 255;

      frequency_count[findex] = frequency_count[heap[1]] +
                                frequency_count[heap_value];
      father[heap_value] =  findex;
      father[heap[1]]    = -findex;
      heap[1]            =  findex;

      reheap (1);
   }

   father[256] = 0;
}

/**************************************************************************
 REHEAP ()
 This function creates a "legal" heap from the current heap tree structure.
 **************************************************************************/
void reheap(unsigned short heap_entry)
{
   register unsigned short  index;
   register unsigned short  flag = 1;

   unsigned long   heap_value;


   heap_value = heap[heap_entry];

   while ((heap_entry <= (heap_length >> 1)) && (flag))
   {
      index = heap_entry << 1;

      if (index < heap_length)
         if (frequency_count[heap[index]] >= frequency_count[heap[index+1]])
            index++;

      if (frequency_count[heap_value] < frequency_count[heap[index]])
	 flag--;
      else
      {
         heap[heap_entry] = heap[index];
         heap_entry       = index;
      }
   }

   heap[heap_entry] = heap_value;
}
/**************************************************************************
 BUILD_INITIAL_HEAP ()
 This function builds a heap from the initial frequency count data.
 **************************************************************************/

void build_initial_heap ()
{
 //  void    reheap ();

   register unsigned short  loop;


   heap_length = 0;

   for (loop = 0; loop < 256; loop++)
      if (frequency_count[loop])
         heap[++heap_length] = (unsigned long) loop;

   for (loop = heap_length; loop > 0; loop--)
      reheap (loop);
}


/**************************************************************************
 GET_FREQUENCY_COUNT ()
 This function counts the number of occurrences of each byte in the data
 that are to be compressed.
 **************************************************************************/
void get_frequency_count ()
{
   register unsigned long  loop;
   for (loop = 0; loop < file_size; loop++)
      frequency_count[getc (ifile)]++;
}