Category

Development Platform
Home > SourceCode/Document > Compress-Decompress algrithms > View Code
DHUFF.C
Package: solitude.rar　[view]
Upload User: szqxhk
Upload Date: 2010-02-15
Package Size: 54k
Code Size: 5k
Category:

Compress-Decompress algrithms

Development Platform:

Visual C++

DHUFF.C：Code Content
  1. /**************************************************************************
  2.  *                                                                        *
  3.  *  DHUFF.C:    Huffman Decompression Program.                            *
  4.  *              14-August-1990    Bill Demas          Version 1.0         *
  5.  *                   *
  6.  *   This program decompresses a file previously compressed with the      *
  7.  *   HUFF1 program.                                                       *
  8.  *                                                                        *
  9.  *           USAGE:   DHUFF <input file> <output file>                    *
  10.  *                   *
  11.  *   (DISK to DISK:  Input direct from disk, output direct to disk)       *
  12.  **************************************************************************/
  15. #include <stdio.h>
  16. #include <stdlib.h>
  18. #define    VERBOSE                          /* If defined, prints verbose
  19.                                                program progress when it's
  20.                                                running...                   */
  22. short           decomp_tree[512];
  23. unsigned short  code[256];
  24. unsigned long   file_size;
  25. unsigned char   code_length[256];
  27. FILE            *ifile, *ofile;
  31. /**************************************************************************
  33.  MAIN ()
  35.  This is the main program. It performs the Huffman decoding procedure in
  36.  2 separate steps.
  38.  I know that this program can be made more compact & faster, but I was more
  39.  interested in UNDERSTANDABILITY !!!
  41.  **************************************************************************/
  43. void main (argc, argv)
  44. int   argc;
  45. char  *argv[];
  46. {
  47.    void  build_decomp_tree (), decompress_image ();
  50.    if (argc == 3)
  51.    {
  52.       printf ("nDHUFF:  Huffman Code Decompression Program.");
  53.       printf ("n        14-Aug-90  Bill Demas.  Version 1.0nn");
  56.       if ((ifile = fopen (argv[1], "rb")) != NULL)
  57.       {
  58.          fread (&file_size, sizeof (file_size), 1, ifile);
  59.          fread (code, 2, 256, ifile);
  60.          fread (code_length, 1, 256, ifile);
  62.          #ifdef VERBOSE
  63.             printf ("(1) Building the tree.n");
  64.          #endif
  66.          build_decomp_tree ();
  68.          #ifdef VERBOSE
  69.             printf ("(2) Decompressing & Creating the Output File.n");
  70.          #endif
  72.          if ((ofile = fopen (argv[2], "wb")) != NULL)
  73.          {
  74.             decompress_image();
  75.             fclose (ofile);
  76.          }
  77.          else
  78.             printf ("nERROR:  Couldn't create output file %sn", argv[2]);
  80.          fclose (ifile);
  81.       }
  82.       else
  83.          printf ("nERROR:  %s -- File not found!n", argv[1]);
  84.    }
  85.    else
  86.       printf ("Usage:  DHUFF <input filename> <output filename>nn");
  87. }
  90. /**************************************************************************
  92.  BUILD_DECOMP_TREE ()
  94.  This function builds the decompression tree.
  95.  **************************************************************************/
  97. void  build_decomp_tree ()
  98. {
  99.    register unsigned short  loop1;
  100.    register unsigned short  current_index;
  102.    unsigned short  loop;
  103.    unsigned short  current_node = 1;
  106.    decomp_tree[1] = 1;
  108.    for (loop = 0; loop < 256; loop++)
  109.    {
  110.       if (code_length[loop])
  111.       {
  112.  current_index = 1;
  113.  for (loop1 = code_length[loop] - 1; loop1 > 0; loop1--)
  114.  {
  115.     current_index = (decomp_tree[current_index] << 1) +
  116.     ((code[loop] >> loop1) & 1);
  117.     if (!(decomp_tree[current_index]))
  118.        decomp_tree[current_index] = ++current_node;
  119.  }
  120.  decomp_tree[(decomp_tree[current_index] << 1) +
  121.    (code[loop] & 1)] = -loop;
  122.       }
  123.    }
  124. }
  127. /**************************************************************************
  129.  DECOMPRESS_IMAGE ()
  131.  This function decompresses the compressed image.
  132.  **************************************************************************/
  134. void  decompress_image ()
  135. {
  136.    register unsigned short  cindex = 1;
  137.    register char            curchar;
  138.    register short           bitshift;
  140.    unsigned long  charcount = 0L;
  143.    while (charcount < file_size)
  144.    {
  145.       curchar = (char) getc (ifile);
  147.       for (bitshift = 7; bitshift >= 0; --bitshift)
  148.       {
  149.  cindex = (cindex << 1) + ((curchar >> bitshift) & 1);
  151.  if (decomp_tree[cindex] <= 0)
  152.  {
  153.     putc ((int) (-decomp_tree[cindex]), ofile);
  155.     if ((++charcount) == file_size)
  156.                bitshift = 0;
  157.             else
  158.                cindex = 1;
  159.  }
  160.  else
  161.     cindex = decomp_tree[cindex];
  162.       }
  163.    }
  164. }