Reading frequency table from a file for decoding should work now, although it is ugly.

Author: davidv171

arithmeticDecoder.go

@@ -1,13 +1,18 @@
 package main
 
+import "fmt"
+
 type ArithmeticDecoder struct {
 	/*
 		- inputBits : the bool array of input bits, that gets shifted for error calculations
 		- symbolInterval: is the calculated symbol interval, that falls between a symbol's high and low value in the model definition
+		- high table is encoded in the file, low table is derived from the high table
 		- step,low,high : step, calculation helper used here for data retention
 		- output: the decoded byte array, decompressed file
 	*/
 	inputBits      []bool
+	highTable      []uint32
+	lowTable       []uint32
 	symbolInterval uint32
 	step           uint32
 	low            uint32
@@ -16,6 +21,15 @@ type ArithmeticDecoder struct {
 }
 
 //The first 256 32-bit bytes are our frequency table, or rather out HIGH table, containing the high value of each symbol
-func readFreqTable(data []byte) {
-
+func (arithmeticDecoder *ArithmeticDecoder) readFreqTable(data []uint8) {
+	highTable := make([]uint32, 256)
+	for i := 4; i < 256*4; i += 4 {
+		if i%4 == 0 {
+			readBytes := data[i-4 : i]
+			convertedInt := bytesToUint32(readBytes)
+			highTable[(i-4)/4] = convertedInt
+		}
+	}
+	fmt.Println(highTable)
+	arithmeticDecoder.highTable = highTable
 }

binaryConversions.go

@@ -16,16 +16,16 @@ func argumentToBinary(argument string) []bool {
 	}
 	return bits
 }
-func byteToBitSlice(byteSlice uint32, length uint8) []bool {
+func byteToBitSlice(bytes uint32, length uint8) []bool {
 	bits := make([]bool, length)
 	var i uint8
 	//The length of 32 means we're decoding a 32 bit sequence
-	//Loop through the byte and turn it into bit sequence using AND and masking
+	//Loop through the and turn it into bit sequence using AND and masking
 	//Using an unsigned integer, so
 	//7 -> 0
 	for i = 0; i < length; i++ {
-		mask := byte(1 << i)
-		if (byteSlice & uint32(mask)) > 0 {
+		mask := uint8(1 << i)
+		if (bytes & uint32(mask)) > 0 {
 			bits[(length-1)-i] = true
 		} else {
 			bits[(length-1)-i] = false
@@ -36,11 +36,11 @@ func byteToBitSlice(byteSlice uint32, length uint8) []bool {
 	return bits
 }
 
-//Takes a 8 sized bool slice and turns it into a single byte, or 4 bytes if we're converting length
-func bitSliceToByte(bitSlice *[]bool, length uint8) []byte {
+//Takes a length*8 sized bool slice and turns it into a single byte, or 4 bytes if we're converting length
+func bitSliceToByte(bitSlice *[]bool, length uint8) []uint8 {
 	var i uint8 = 0
 	var j uint8 = 0
-	resultingBytes := make([]byte, length)
+	resultingBytes := make([]uint8, length)
 	for i = 0; i < length; i++ {
 		for j = 0; j < 8; j++ {
 			if (*bitSlice)[(i*8)+j] {
@@ -51,3 +51,11 @@ func bitSliceToByte(bitSlice *[]bool, length uint8) []byte {
 
 	return resultingBytes
 }
+func bytesToUint32(data []uint8) uint32 {
+	var returnValue uint32 = 0
+	returnValue |= uint32(data[3])
+	returnValue |= uint32(data[2]) << 8
+	returnValue |= uint32(data[1]) << 16
+	returnValue |= uint32(data[0]) << 24
+	return returnValue
+}

binaryIO.go

@@ -50,6 +50,9 @@ func readBinaryFile(arithmeticCoder *ArithmeticCoder, filepath string, operation
 			} else {
 				arithmeticCoder.intervalCalculation(data)
 			}
+		} else if operation == "d" {
+			arithmeticDecoder.readFreqTable(data)
+
 		}
 		bufferOverflow += bufferSize
 		//So we're aware of indexes if the file is larger
@@ -58,7 +61,7 @@ func readBinaryFile(arithmeticCoder *ArithmeticCoder, filepath string, operation
 	- if low < firstQuarter : output 01 and E3_COUNTER times bit 1
 	- else : output 10 and E3_COUNTER times bit 0
 	*/
-	if !modelCreation {
+	if !modelCreation && arithmeticCoder != nil {
 		writeEncoded(arithmeticCoder)
 		//fmt.Println("The rest:")
 

main.go

@@ -14,6 +14,7 @@ func main() {
 	operation := os.Args[1]
 	inputFile := os.Args[2]
 	outputFile := os.Args[3]
+	var upperLimit uint32 = 4294967295
 	//Compression
 	if operation == "c" {
 		/*
@@ -29,17 +30,35 @@ func main() {
 		//TODO: turn this into output byte array
 		outputBits := make([]bool, 0)
 		//4294967295
-		var upperLimit uint32 = 4294967295
 		//Initialize an arithmetic codec with empty values except for the upper limit, which has the value of 2^32-1
 		//After creating the model is done, we go on to interval creation
-		arithmeticCoder := &ArithmeticCoder{frequencyTable, highTable, lowTable, readSequence, 0, upperLimit, 0, upperLimit, 0, 0, quarters, 0, outputBits}
+		arithmeticCoder := &ArithmeticCoder{frequencyTable, highTable, lowTable,
+			readSequence, 0, upperLimit, 0, upperLimit,
+			0, 0, quarters, 0, outputBits}
 		arithmeticCoder.quarterize(upperLimit)
 		//The last argument is for the arithmetic decoder, whenever we are not decoding, it's nil
 		readBinaryFile(arithmeticCoder, inputFile, operation, true, nil)
 		readBinaryFile(arithmeticCoder, inputFile, operation, false, nil)
 		fmt.Print("Ouputting to... ", outputFile)
 		//Decomepression, read compressed file, deconstruct the symbols based off of it
 	} else if operation == "d" {
-
+		/*	inputBits      []bool
+			highTable []uint32
+			lowTable []uint32
+			symbolInterval uint32
+			step           uint32
+			low            uint32
+			high           uint32
+			output         []byte
+		}*/
+		inputBits := make([]bool, 0)
+		highTable := make([]uint32, 0)
+		lowTable := make([]uint32, 0)
+		var symbolInterval uint32 = 0
+		var step uint32 = 0
+		output := make([]byte, 0)
+		arithmeticDecoder := &ArithmeticDecoder{inputBits, highTable, lowTable,
+			symbolInterval, step, 0, upperLimit, output}
+		readBinaryFile(nil, inputFile, operation, false, arithmeticDecoder)
 	}
 }