ulvis.paste.net

Paste Search Dynamic
Recent pastes
File decompressor for
  1. /*# include */
  2. # include <stdio.h>
  3. # include <stdlib.h>
  4. # include <io.h>
  5.  
  6.  
  7. /*Global variable declarations ***/
  8. struct node
  9. {
  10.         unsigned char c;
  11.         unsigned long int freq;
  12.         struct node *up,*left,*right;
  13. };
  14. struct ftable
  15. {
  16.         unsigned long int freq;
  17. };
  18. struct ftable ft;
  19. struct node leaf[256];
  20. struct node *t[256];
  21. struct node *a,*b,*r1,*r2,*r3;
  22. int i,j,k;
  23. int buf[50],bc;
  24. int buft[20],bct;
  25. int buftv[20];
  26. unsigned char q;
  27. long int y=0;/*For debugging*/
  28.  
  29. /*Function prototype declarations*/
  30. int getzero();
  31. int sortt(int);
  32. int maketree();
  33. void init();
  34. int retrieveft(char *);
  35. void add2buff(int);
  36. void refreshbuffer(file *);
  37. //#include "h.h"
  38.  
  39. int getzero()
  40. {
  41.         int h=0;
  42.         for(i=0;i<256;i++)
  43.         {
  44.                 if(leaf[i].freq==0)
  45.                         h++;
  46.         }
  47.         return (255-h);
  48. }
  49.  
  50.  
  51. int sortt(int z)/*sorts upto t[z] and not t[z-1]*/
  52. {
  53.         for(k=0;k<=z;k++)
  54.         for(j=(k+1);j<=z;j++)
  55.         {
  56.                 if((t[k]->freq)<(t[j]->freq))
  57.                 {
  58.                         /*b=NULL;*/
  59.                         b=t[k];
  60.                         t[k]=t[j];
  61.                         t[j]=b;
  62.                 }
  63.         }
  64.         return 0;
  65. }
  66.  
  67. int maketree()
  68. {
  69.         int n;
  70.         struct node *a;
  71.         sortt(255);
  72.         for(i=getzero();i>0;i--)
  73.         {
  74.                 sortt(i);
  75.                 a=null;
  76.                 a=(struct node *)malloc(sizeof(struct node));
  77.                 if(a==null)
  78.                 {
  79.                         printf("\nMemory allocation error...");
  80.                         getch();
  81.                         return -1;  /*Memory allocation error*/
  82.                 }
  83.                 /*Assingning values*/
  84.                 a->freq=(t[i]->freq)+(t[i-1]->freq);
  85.                 a->right=t[i];
  86.                 a->left=t[i-1];
  87.                 a->up=null;
  88.                 a->c='\0';
  89.                 t[i]->up=a;
  90.                 t[i-1]->up=a;
  91.                 /*Changing the pointer*/
  92.                 t[i-1]=a;
  93.         }
  94.  
  95.  
  96.  
  97. printf("ENTER THE LEBEL TO CHANGE :");
  98. scanf("%d",&n);
  99. r1=a;r2=a;
  100. for(i=0;i<n;i++)
  101. {
  102. if(r1->left!=null)
  103. {
  104. r1=r1->left;
  105. }
  106. if(r2->right!=null)
  107. {
  108. r2=r2->right;
  109. }
  110. }
  111. r3=r1->left;
  112. r1->left=r2->right;
  113. r2->right=r3;
  114. r3='\0';
  115. r1->left->up=r1;
  116. r1->right->up=r1;
  117. r2->left->up=r2;
  118. r2->right->up=r2;
  119.  
  120.  
  121.         return 0;
  122. }
  123. void init()
  124. {
  125.         int i;
  126.         for(i=0;i<256;i++)
  127.         {
  128.                 leaf[i].c=(unsigned char)i;
  129.                 leaf[i].freq=0;
  130.                 leaf[i].up=null;
  131.                 leaf[i].left=null;
  132.                 leaf[i].right=null;
  133.                 t[i]=&leaf[i];
  134.         }
  135.         for(i=0;i<256;i++)
  136.         {
  137.                 t[i]=&leaf[i];
  138.         }
  139.         return;
  140. }
  141.  
  142. int retrieveft(char *filename)
  143. {
  144.         file *p;
  145.         p=fopen(filename,"rb");
  146.         if(p==null)
  147.         {
  148.                 return -1;/*Could not open file */
  149.         }
  150.         for(i=0;i<256;i++)
  151.         {
  152.                 fread(&ft,sizeof(struct ftable),1,p);
  153.                 leaf[i].c=(unsigned char)i;
  154.                 leaf[i].freq=ft.freq;
  155.                 leaf[i].up=null;
  156.                 leaf[i].right=null;
  157.                 leaf[i].left=null;
  158.         }
  159.         fclose(p);
  160.         return 0;
  161. }
  162. void add2buff(int c)
  163. {
  164.         bct=-1;
  165.         while(c!=0)
  166.         {
  167.                 buft[++bct]=(c%2);
  168.                 c/=2;
  169.         }
  170.         for(i=(bct+1);i<8;i++)
  171.         {
  172.                 buft[i]=0;
  173.         }
  174.         for(i=(0);i<8;i++)
  175.         {
  176.                 buftv[7-i]=buft[i];
  177.         }
  178.         for(i=0;i<8;i++)
  179.         {
  180.                 buf[bc+i]=buftv[i];
  181.         }
  182.         bc+=8;
  183. }
  184.  
  185. void refreshbuffer(file *p)
  186. {
  187.         int count=0,j,i;
  188.         //int bcbak=bc;
  189.         a=t[0];i=0;
  190.         for(i=0;i<=bc;i++)
  191.         {
  192.                 if(a->left==null && a->right==null)
  193.                 {
  194.                         fputc(a->c,p);
  195.                         /*For debugging*/
  196.                         y++;
  197.                         /*debugging over*/
  198.                         for(j=count;j<bc;j++)
  199.                         {
  200.                                 buf[j-count]=buf[j];
  201.                         }
  202.                         bc-=count;
  203.                         //i=0;
  204.                         count=0;
  205.                         a=t[0];
  206.                 }
  207.                 else if(buf[count]==0)
  208.                 {
  209.                         a=a->left;
  210.                         count++;
  211.                         //i++;
  212.                 }
  213.                 else if(buf[count]==1)
  214.                 {
  215.                         a=a->right;
  216.                         count++;
  217.                         //i++;
  218.                 }
  219.                 else
  220.                 {
  221.                         printf("\nError");
  222.                 }
  223.         }
  224.         return;
  225. }
  226.  
  227.  
  228. main()
  229. {
  230.         char filename[100],outfile[100];
  231.         file *p,*q;
  232.         int ch,ct;
  233.         long int filelen,count=1024;
  234.         clrscr();
  235.  
  236.         printf("\nFile decompressor for files compressed with HuffEnc");
  237.  
  238.         printf("\nEnter the filename:");scanf("%s",filename);
  239.         init();
  240.         if(retrieveft(filename)==-1)
  241.         {
  242.                 printf("\nCould not open file");
  243.                 return -1;
  244.         }
  245.         maketree();
  246.         /*To retrieve the filename from the compressed file*/
  247.         p=fopen(filename,"rb");
  248.         fseek(p,1024,seek_set);
  249.         ct=fgetc(p);
  250.         fread(outfile,ct,1,p);
  251.         /***Filename retrieval finished*/
  252.         p=fopen(filename,"rb");
  253.         /***check for user renaming of output file*/
  254.         printf("\nThe specified archive contains a compressed file called %s",outfile);
  255.         printf("\nYou may choose to create this file or specify a name for the file to be created");
  256.         printf("\nSpecify a name for the output file(y/any other key):");
  257.         if(tolower(getch())=='y')
  258.         {
  259.                 printf("\n\nEnter name for file to be created:");scanf("%s",outfile);
  260.         }
  261.         /******check for renaming complete*****/
  262.         q=fopen(outfile,"wb");
  263.         if(q==null || p==null)
  264.         {
  265.                 printf("\nCould not open one or more files");
  266.                 fcloseall();
  267.                 return -1;
  268.         }
  269.         fseek(p,256*sizeof(struct ftable)+1+ct,seek_set);
  270.         filelen=filelength(fileno(p));
  271.         count=1024+1+ct;
  272.         printf("\n\nInitialization over.\nPreparing to decompress..");
  273.         printf("\nDecompressing....");
  274.         while(ch=fgetc(p),count++,ch!=eof)
  275.         {
  276.                 if(count==(filelen-1))
  277.                 {
  278.                         add2buff(ch);
  279.                         bc-=8;
  280.                         bc+=fgetc(p);
  281.                         refreshbuffer(q);
  282.                         while(bc!=0)
  283.                         {
  284.                                 refreshbuffer(q);
  285.                         }
  286.                 }
  287.                 else
  288.                 {
  289.                         add2buff(ch);
  290.                         refreshbuffer(q);
  291.                 }
  292.         }
  293.         printf("\nDecompression complete.\n");
  294.         printf("\nCreated output file %s ",outfile);
  295.         printf("\n\nThank you.");
  296.         return 0;
  297. }
  298.  
  299.  
  300.  
  301.  
Parsed in 0.070 seconds