chore: Refactor

Author: ayonious

FileCompression.jar

@@ -7,82 +7,18 @@
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.PrintStream;
+import java.util.Arrays;
 import java.util.PriorityQueue;
 
+import prog.lzw.LzwCompressor;
+
 //if the frequency of a byte is more than 2^32 then there will be problem
 public class HuffmanCompressor {
-
-	static PriorityQueue<HuffmanNode> priorityQueue = new PriorityQueue<HuffmanNode>();
-	static int[] frequency = new int[300];
-	static String[] huffmanCodes = new String[300];
-	static int extraBits;
-	static byte currentByte;
-	static int uniqueCharCount; // number of different characters
-
-	// for keeping frequncies of all the bytes
-
-	// main tree class
-
-	static HuffmanNode root;
-
-	/*******************************************************************************
-	 * calculating frequence of file filename
-	 ******************************************************************************/
-	public static void calculateFrequencyOfBytesInFile(String filename) {
-		File file = new File(filename);;
-		Byte currentByte;
-		try {
-			FileInputStream file_input = new FileInputStream(file);
-			DataInputStream data_in = new DataInputStream(file_input);
-			while (true) {
-				try {
-
-					currentByte = data_in.readByte();
-					frequency[HuffmanUtils.to(currentByte)]++;
-				} catch (EOFException eof) {
-					System.out.println("End of File");
-					break;
-				}
-			}
-			file_input.close();
-			data_in.close();
-		} catch (IOException e) {
-			System.out.println("IO Exception =: " + e);
-		}
-	}
-
-	/************************************** ============ ************************/
-
-	/***********************************************************************************
-	 * byte to binary conversion
-	 ***********************************************************************************/
-	public static int to(Byte b) {
-		int ret = b;
-		if (ret < 0) {
-			ret = ~b;
-			ret = ret + 1;
-			ret = ret ^ 255;
-			ret += 1;
-		}
-		return ret;
-	}
-
-	/***********************************************************************************/
-
 	/**********************************************************************************
 	 * freing the memory
 	 *********************************************************************************/
-	public static void initHuffmanCompressor() {
-		int i;
-		uniqueCharCount = 0;
-		if (root != null)
-			HuffmanUtils.fredfs(root, HuffmanUtils.HUFFMAN_TREE_ACCESSOR);
-		for (i = 0; i < 300; i++)
-			frequency[i] = 0;
-		for (i = 0; i < 300; i++)
-			huffmanCodes[i] = "";
-		priorityQueue.clear();
+	public static void initHuffmanCompressor(HuffmanNode root) {
+		if (root != null) HuffmanUtils.fredfs(root, HuffmanUtils.HUFFMAN_TREE_ACCESSOR);
 	}
 
 	/**********************************************************************************/
@@ -106,26 +42,26 @@ public static void fredfs(HuffmanNode node) {
 	/**********************************************************************************
 	 * dfs to make the codes
 	 *********************************************************************************/
-	public static void generateHuffmanCodes(HuffmanNode node, String code) {
+	public static void generateHuffmanCodes(HuffmanNode node, String code, String[] huffmanCodes) {
 		node.code = code;
 		if ((node.leftChild == null) && (node.rightChild == null)) {
 			huffmanCodes[node.byteValue] = code;
 			return;
 		}
 		if (node.leftChild != null)
-			generateHuffmanCodes(node.leftChild, code + "0");
+			generateHuffmanCodes(node.leftChild, code + "0", huffmanCodes);
 		if (node.rightChild != null)
-			generateHuffmanCodes(node.rightChild, code + "1");
+			generateHuffmanCodes(node.rightChild, code + "1", huffmanCodes);
 	}
 
 	/**********************************************************************************/
 
 	/*******************************************************************************
 	 * Making all the nodes in a priority Q making the tree
 	 *******************************************************************************/
-	public static void buildHuffmanTree() {
+	public static HuffmanNode buildHuffmanTree(int[] frequency, String[] huffmanCodes) {
 		int i;
-		priorityQueue.clear();
+		PriorityQueue<HuffmanNode> priorityQueue = new PriorityQueue<HuffmanNode>();
 
 		for (i = 0; i < 300; i++) {
 			if (frequency[i] != 0) {
@@ -135,21 +71,20 @@ public static void buildHuffmanTree() {
 				Temp.leftChild = null;
 				Temp.rightChild = null;
 				priorityQueue.add(Temp);
-				uniqueCharCount++;
 			}
 
 		}
 		HuffmanNode Temp1, Temp2;
 
-		if (uniqueCharCount == 0) {
-			return;
-		} else if (uniqueCharCount == 1) {
+		if (Arrays.stream(frequency).filter(f -> f != 0).count() == 0) {
+			return null;
+		} else if (Arrays.stream(frequency).filter(f -> f != 0).count() == 1) {
 			for (i = 0; i < 300; i++)
 				if (frequency[i] != 0) {
 					huffmanCodes[i] = "0";
 					break;
 				}
-			return;
+			return null;
 		}
 
 		// will there b a problem if the file is empty
@@ -163,178 +98,95 @@ public static void buildHuffmanTree() {
 			Temp.frequency = Temp1.frequency + Temp2.frequency;
 			priorityQueue.add(Temp);
 		}
-		root = priorityQueue.poll();
+		HuffmanNode root = priorityQueue.poll();
+		return root;
 	}
 
 	/*******************************************************************************/
 
-	/*******************************************************************************
-	 * encrypting
-	 *******************************************************************************/
-	public static void encrypt(String filename) {
-		File file = null;
-
-		file = new File(filename);
-		try {
-			FileInputStream file_input = new FileInputStream(file);
-			DataInputStream data_in = new DataInputStream(file_input);
-			while (true) {
-				try {
-
-					currentByte = data_in.readByte();
-					frequency[currentByte]++;
-				} catch (EOFException eof) {
-					System.out.println("End of File");
-					break;
-				}
-			}
-			file_input.close();
-			data_in.close();
-
-		} catch (IOException e) {
-			System.out.println("IO Exception =: " + e);
-		}
-		file = null;
-	}
-
-	/*******************************************************************************/
-
-	/*******************************************************************************
-	 * fake zip creates a file "fakezip.txt" where puts the final binary codes
-	 * of the real zipped file
-	 *******************************************************************************/
-	public static void fakezip(String filename) {
 
+	public static void zip(String filename, String filename1, int[] frequency, String[] huffmanCodes) {
 		File filei, fileo;
 		int i;
-
-		filei = new File(filename);
-		fileo = new File("fakezipped.txt");
-		try {
-			FileInputStream file_input = new FileInputStream(filei);
-			DataInputStream data_in = new DataInputStream(file_input);
-			PrintStream ps = new PrintStream(fileo);
-
-			while (true) {
-				try {
-					currentByte = data_in.readByte();
-					ps.print(huffmanCodes[to(currentByte)]);
-				} catch (EOFException eof) {
-					System.out.println("End of File");
-					break;
-				}
-			}
-
-			file_input.close();
-			data_in.close();
-			ps.close();
-
-		} catch (IOException e) {
-			System.out.println("IO Exception =: " + e);
-		}
-		filei = null;
-		fileo = null;
-
-	}
-
-	/*******************************************************************************/
-
-	/*******************************************************************************
-	 * real zip according to codes of fakezip.txt (filename)
-	 *******************************************************************************/
-	public static void realzip(String filename, String filename1) {
-		File filei, fileo;
-		int i, j = 10;
 		Byte currentBytet;
 
 		filei = new File(filename);
 		fileo = new File(filename1);
 
+		DataInputStream dataIn;
+		DataOutputStream dataOut;
+
 		try {
+
 			FileInputStream file_input = new FileInputStream(filei);
-			DataInputStream data_in = new DataInputStream(file_input);
+			dataIn = new DataInputStream(file_input);
 			FileOutputStream file_output = new FileOutputStream(fileo);
-			DataOutputStream data_out = new DataOutputStream(file_output);
+			dataOut = new DataOutputStream(file_output);
 
-			data_out.writeInt(uniqueCharCount);
+			// Step1: Write the table size
+			dataOut.writeInt((int)Arrays.stream(frequency).filter(f -> f != 0).count());
+
+			// Step2: Write the table
 			for (i = 0; i < 256; i++) {
 				if (frequency[i] != 0) {
 					currentBytet = (byte) i;
-					data_out.write(currentBytet);
-					data_out.writeInt(frequency[i]);
+					dataOut.write(currentBytet);
+					dataOut.writeInt(frequency[i]);
+				}
+			}
+			
+			// Step3: Because the table might have some padding to make it a multiple of 8,
+			//we need to calculate the total number of binary digits mod 8
+			int totalBinaryDigitsMod8 = 0;
+			for(i = 0; i < 256; i++) {
+				if (huffmanCodes[i] != null) {
+					totalBinaryDigitsMod8 += huffmanCodes[i].length() * frequency[i];
+					totalBinaryDigitsMod8 %= 8;
 				}
 			}
-			long textraBits;
-			textraBits = filei.length() % 8;
-			textraBits = (8 - textraBits) % 8;
-			extraBits = (int) textraBits;
-			data_out.writeInt(extraBits);
+			int extraBits = (8 - totalBinaryDigitsMod8)%8;
+			dataOut.writeInt(extraBits);
+
+
+			String bitBuffer = "";
 			while (true) {
 				try {
-					currentByte = 0;
-					byte ch;
-					for (extraBits = 0; extraBits < 8; extraBits++) {
-						ch = data_in.readByte();
-						currentByte *= 2;
-						if (ch == '1')
-							currentByte++;
+					byte currentByte = dataIn.readByte();
+					String huffmanCodeOfCurrentByte = huffmanCodes[HuffmanUtils.to(currentByte)];
+					bitBuffer += huffmanCodeOfCurrentByte;
+					while(bitBuffer.length() >= 8) {
+						dataOut.write(LzwCompressor.stringToByte(bitBuffer.substring(0, 8)));
+						bitBuffer = bitBuffer.substring(8, bitBuffer.length());
 					}
-					data_out.write(currentByte);
-
 				} catch (EOFException eof) {
 					int x;
-					if (extraBits != 0) {
-						for (x = extraBits; x < 8; x++) {
-							currentByte *= 2;
-						}
-						data_out.write(currentByte);
+					if (bitBuffer.length() != 0) {
+						dataOut.write(LzwCompressor.stringToByte(bitBuffer));
 					}
-
-					extraBits = (int) textraBits;
-					System.out.println("extrabits: " + extraBits);
-					System.out.println("End of File");
 					break;
 				}
 			}
-			data_in.close();
-			data_out.close();
+			dataIn.close();
+			dataOut.close();
 			file_input.close();
 			file_output.close();
 			System.out.println("output file's size: " + fileo.length());
 
 		} catch (IOException e) {
 			System.out.println("IO exception = " + e);
 		}
-		filei.delete();
 		filei = null;
 		fileo = null;
 	}
 
-	/*******************************************************************************/
-
-	/*
-	 * public static void main (String[] args) { initHzipping();
-	 * CalFreq("in.txt"); // calculate the frequency of each digit MakeNode();
-	 * // makeing corresponding nodes if(uniqueCharCount>1) generateHuffmanCodes(root,""); // dfs to make the
-	 * codes fakezip("in.txt"); // fake zip file which will have the binary of
-	 * the input to fakezipped.txt file
-	 * realzip("fakezipped.txt","in.txt"+".huffz"); // making the real zip
-	 * according the fakezip.txt file initHzipping();
-	 * 
-	 * }
-	 */
-
 	public static void beginHuffmanCompression(String arg1) {
-		initHuffmanCompressor();
-		calculateFrequencyOfBytesInFile(arg1); // calculate the frequency of each digit
-		buildHuffmanTree(); // build huffman tree from frequencies
-		if (uniqueCharCount > 1)
-			generateHuffmanCodes(root, ""); // dfs to make the codes
-		fakezip(arg1); // fake zip file which will have the binary of the input
-						// to fakezipped.txt file
-		realzip("fakezipped.txt", arg1 + ".huffz"); // making the real zip
-													// according the fakezip.txt
-													// file
-		initHuffmanCompressor();
+		initHuffmanCompressor(null);
+		int[] frequency = HuffmanUtils.calculateFrequencyOfBytesInFile(arg1); // calculate the frequency of each digit
+		String[] huffmanCodes = new String[300];
+		HuffmanNode huffmanTree = buildHuffmanTree(frequency, huffmanCodes); // build huffman tree from frequencies
+		if (Arrays.stream(frequency).filter(f -> f != 0).count() > 1)
+			generateHuffmanCodes(huffmanTree, "", huffmanCodes); // dfs to make the codes
+		zip(arg1, arg1 + ".huffz", frequency, huffmanCodes); // compress the file directly
+		initHuffmanCompressor(huffmanTree);
 	}
 }