From 4e71a481884c0c43aea3d0ee695ae68cdec56478 Mon Sep 17 00:00:00 2001 From: BiSaXa <1669855+BiSaXa@users.noreply.github.com> Date: Wed, 7 Sep 2022 19:40:16 +0300 Subject: first rewrite commit using bisaxa/bitreader --- classes/classes.go | 155 +++++++++++++++++++++++++++++++++++++++++++++++++ classes/cmdInfo.go | 25 -------- classes/stringTable.go | 27 --------- classes/types.go | 28 +++++++++ classes/userCmdInfo.go | 72 ----------------------- go.mod | 2 + go.sum | 4 ++ main.go | 14 +++-- messages/header.go | 26 +++++++++ messages/messages.go | 91 ++++++++++------------------- messages/types.go | 12 ++-- utils/bitreader.go | 94 ------------------------------ utils/utils.go | 44 +------------- 13 files changed, 259 insertions(+), 335 deletions(-) create mode 100644 classes/classes.go delete mode 100644 classes/cmdInfo.go delete mode 100644 classes/stringTable.go create mode 100644 classes/types.go delete mode 100644 classes/userCmdInfo.go create mode 100644 messages/header.go delete mode 100644 utils/bitreader.go diff --git a/classes/classes.go b/classes/classes.go new file mode 100644 index 0000000..beaab77 --- /dev/null +++ b/classes/classes.go @@ -0,0 +1,155 @@ +package classes + +import ( + "os" + + "github.com/bisaxa/bitreader" + "github.com/bisaxa/demoparser/utils" +) + +func ParseCmdInfo(file *os.File, MSSC int) []CmdInfo { + reader := bitreader.Reader(file, true) + var cmdinfo CmdInfo + var cmdinfoarray []CmdInfo + for count := 0; count < MSSC; count++ { + cmdinfo.Flags = int32(reader.TryReadInt32()) + var floatArray [3]float32 + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.ViewOrigin = floatArray[:] + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.ViewAngles = floatArray[:] + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.LocalViewAngles = floatArray[:] + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.ViewOrigin2 = floatArray[:] + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.ViewAngles2 = floatArray[:] + for i := 0; i < 3; i++ { + floatArray[i] = reader.TryReadFloat32() + } + cmdinfo.LocalViewAngles2 = floatArray[:] + cmdinfoarray = append(cmdinfoarray, cmdinfo) + } + return cmdinfoarray +} + +func ParseUserCmdInfo(file *os.File, size int) UserCmdInfo { + count := 0 + reader := bitreader.Reader(file, true) + var usercmd UserCmdInfo + flag, err := reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.CommandNumber = int32(reader.TryReadInt32()) + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.TickCount = int32(reader.TryReadInt32()) + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.ViewAnglesX = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.ViewAnglesY = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.ViewAnglesZ = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.ForwardMove = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.SideMove = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.UpMove = reader.TryReadFloat32() + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.Buttons = int32(reader.TryReadInt32()) + count += 32 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + //reader.SkipBits(8) + usercmd.Impulse = int8(reader.TryReadInt8()) + count += 8 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + value, err := reader.ReadBits(11) + utils.CheckError(err) + usercmd.WeaponSelect = int(value) + flag, err = reader.ReadBool() + utils.CheckError(err) + count += 11 + if flag { + value, err := reader.ReadBits(6) + utils.CheckError(err) + usercmd.WeaponSubtype = int(value) + count += 6 + } + count++ + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.MouseDx = int16(reader.TryReadInt16()) + count += 16 + } + count++ + flag, err = reader.ReadBool() + utils.CheckError(err) + if flag { + usercmd.MouseDy = int16(reader.TryReadInt16()) + count += 16 + } + count++ + reader.SkipBits(size*8 - count) + return usercmd +} diff --git a/classes/cmdInfo.go b/classes/cmdInfo.go deleted file mode 100644 index 7e7e1bc..0000000 --- a/classes/cmdInfo.go +++ /dev/null @@ -1,25 +0,0 @@ -package classes - -import "github.com/bisaxa/demoparser/utils" - -type CmdInfo struct { - Flags int32 - ViewOrigin []float32 - ViewAngles []float32 - LocalViewAngles []float32 - ViewOrigin2 []float32 - ViewAngles2 []float32 - LocalViewAngles2 []float32 -} - -func CmdInfoInit(bytes []byte) (output CmdInfo) { - var class CmdInfo - class.Flags = int32(utils.IntFromBytes(bytes[:4])) - class.ViewOrigin = utils.FloatArrFromBytes(bytes[4:16]) - class.ViewAngles = utils.FloatArrFromBytes(bytes[16:28]) - class.LocalViewAngles = utils.FloatArrFromBytes(bytes[28:40]) - class.ViewOrigin2 = utils.FloatArrFromBytes(bytes[40:52]) - class.ViewAngles2 = utils.FloatArrFromBytes(bytes[52:64]) - class.LocalViewAngles2 = utils.FloatArrFromBytes(bytes[64:76]) - return class -} diff --git a/classes/stringTable.go b/classes/stringTable.go deleted file mode 100644 index 0833612..0000000 --- a/classes/stringTable.go +++ /dev/null @@ -1,27 +0,0 @@ -package classes - -type StringTable struct { - NumOfTables int32 - TableName string - NumOfEntries int16 - EntryName string - EntrySize int16 - EntryData []byte - NumOfClientEntries int16 - ClientEntryName string - ClientEntrySize int16 - ClientEntryData []byte -} - -/* -func StringTableInit(bytes []byte) (output StringTable) { - var class StringTable - class.NumOfTables = int(utils.IntFromBytes(bytes[:1])) - class.TableName = string(bytes[1:16]) - class.ViewAngles = utils.FloatArrFromBytes(bytes[16:28]) - class.LocalViewAngles = utils.FloatArrFromBytes(bytes[28:40]) - class.ViewOrigin2 = utils.FloatArrFromBytes(bytes[40:52]) - class.ViewAngles2 = utils.FloatArrFromBytes(bytes[52:64]) - class.LocalViewAngles2 = utils.FloatArrFromBytes(bytes[64:76]) - return class -}*/ diff --git a/classes/types.go b/classes/types.go new file mode 100644 index 0000000..3fcc692 --- /dev/null +++ b/classes/types.go @@ -0,0 +1,28 @@ +package classes + +type CmdInfo struct { + Flags int32 + ViewOrigin []float32 + ViewAngles []float32 + LocalViewAngles []float32 + ViewOrigin2 []float32 + ViewAngles2 []float32 + LocalViewAngles2 []float32 +} + +type UserCmdInfo struct { + CommandNumber int32 + TickCount int32 + ViewAnglesX float32 + ViewAnglesY float32 + ViewAnglesZ float32 + ForwardMove float32 + SideMove float32 + UpMove float32 + Buttons int32 + Impulse int8 + WeaponSelect int + WeaponSubtype int + MouseDx int16 + MouseDy int16 +} diff --git a/classes/userCmdInfo.go b/classes/userCmdInfo.go deleted file mode 100644 index d2de229..0000000 --- a/classes/userCmdInfo.go +++ /dev/null @@ -1,72 +0,0 @@ -package classes - -import ( - "fmt" - - "github.com/bisaxa/demoparser/utils" -) - -type UserCmdInfo struct { - CommandNumber int32 - TickCount int32 - ViewAnglesX float32 - ViewAnglesY float32 - ViewAnglesZ float32 - ForwardMove float32 - SideMove float32 - UpMove float32 - Buttons int32 - // Impulse byte } - // WeaponSelect int32 } - // WeaponSubtype int32 Not worth the effort, no one cares about these - // MouseDx int16 } - // MouseDy int } -} - -// It is so janky it hurts, but hey it is at least working (hopefully) -// Reading the data is really weird, who even implemented this smh -func UserCmdInfoInit(byteArr []byte, size int32) (output UserCmdInfo) { - var class UserCmdInfo - successCount := 0 - failedCount := 0 - looped := 0 - classIndex := 0 - //fmt.Println(byteArr) - fmt.Printf("%08b\n", byteArr) - for i := 0; i < 9; i++ { - if successCount+failedCount > 7 { - failedCount = -successCount - looped++ - } - firstBit, err := utils.ReadBitStateLSB(byteArr[successCount*4+looped], successCount+failedCount) - utils.CheckError(err) - if firstBit { - successCount++ - switch classIndex { - case 0: - class.CommandNumber = utils.Read32BitsAfterFirstBitInt32(byteArr, successCount+failedCount, successCount*4+looped) - case 1: - class.TickCount = utils.Read32BitsAfterFirstBitInt32(byteArr, successCount+failedCount, successCount*4+looped) - case 2: - class.ViewAnglesX = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 3: - class.ViewAnglesY = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 4: - class.ViewAnglesZ = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 5: - class.ForwardMove = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 6: - class.SideMove = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 7: - class.UpMove = utils.Read32BitsAfterFirstBitFloat32(byteArr, successCount+failedCount, successCount*4+looped) - case 8: - class.Buttons = utils.Read32BitsAfterFirstBitInt32(byteArr, successCount+failedCount, successCount*4+looped) - } - classIndex++ - } else { - failedCount++ - classIndex++ - } - } - return class -} diff --git a/go.mod b/go.mod index c8d836c..0ce207c 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,5 @@ module github.com/bisaxa/demoparser go 1.19 + +require github.com/bisaxa/bitreader v1.0.1-0.20220907151525-64e0e23b8a0f diff --git a/go.sum b/go.sum index e69de29..394545f 100644 --- a/go.sum +++ b/go.sum @@ -0,0 +1,4 @@ +github.com/bisaxa/bitreader v1.0.1-0.20220907142402-05d7eb4e0f7b h1:OBmlKXvF6Uo+uMowYnu3y3BJWAnZlQzLAJYuwXS97HI= +github.com/bisaxa/bitreader v1.0.1-0.20220907142402-05d7eb4e0f7b/go.mod h1:AKIwOt+ZqRtuT7SyjGAF8x0kVPhlK8fgTVMlPEh7d0I= +github.com/bisaxa/bitreader v1.0.1-0.20220907151525-64e0e23b8a0f h1:b48EQo2AaOOAxsWGk3NI+ZJDrXe9YT9KKSXz/agSuzQ= +github.com/bisaxa/bitreader v1.0.1-0.20220907151525-64e0e23b8a0f/go.mod h1:AKIwOt+ZqRtuT7SyjGAF8x0kVPhlK8fgTVMlPEh7d0I= diff --git a/main.go b/main.go index a60f0e8..8def33d 100644 --- a/main.go +++ b/main.go @@ -7,7 +7,6 @@ import ( "os" "github.com/bisaxa/demoparser/messages" - "github.com/bisaxa/demoparser/utils" ) func main() { @@ -17,12 +16,13 @@ func main() { files, err := ioutil.ReadDir(os.Args[1]) if err != nil { // If it's not a directory file, err := os.Open(os.Args[1]) - utils.CheckError(err) + if err != nil { + panic(err) + } messages.ParseHeader(file) for { code := messages.ParseMessage(file) if code == 7 { - messages.ParseMessage(file) break } } @@ -30,15 +30,17 @@ func main() { } for _, fileinfo := range files { // If it is a directory file, err := os.Open(os.Args[1] + fileinfo.Name()) - utils.CheckError(err) - messages.ParseHeader(file) + if err != nil { + panic(err) + } + /*messages.ParseHeader(file) for { code := messages.ParseMessage(file) if code == 7 { messages.ParseMessage(file) break } - } + }*/ defer file.Close() } fmt.Scanln() diff --git a/messages/header.go b/messages/header.go new file mode 100644 index 0000000..6320c71 --- /dev/null +++ b/messages/header.go @@ -0,0 +1,26 @@ +package messages + +import ( + "fmt" + "os" + + "github.com/bisaxa/bitreader" + "github.com/bisaxa/demoparser/utils" +) + +func ParseHeader(file *os.File) { + var header Header + reader := bitreader.Reader(file, true) + header.DemoFileStamp = string(utils.ReadByteFromFile(file, 8)) + header.DemoProtocol = int32(reader.TryReadInt32()) + header.NetworkProtocol = int32(reader.TryReadInt32()) + header.ServerName = string(utils.ReadByteFromFile(file, 260)) + header.ClientName = string(utils.ReadByteFromFile(file, 260)) + header.MapName = string(utils.ReadByteFromFile(file, 260)) + header.GameDirectory = string(utils.ReadByteFromFile(file, 260)) + header.PlaybackTime = float32(reader.TryReadFloat32()) + header.PlaybackTicks = int32(reader.TryReadInt32()) + header.PlaybackFrames = int32(reader.TryReadInt32()) + header.SignOnLength = int32(reader.TryReadInt32()) + fmt.Printf("%+v", header) +} diff --git a/messages/messages.go b/messages/messages.go index a2b0ebd..4d94728 100644 --- a/messages/messages.go +++ b/messages/messages.go @@ -4,97 +4,66 @@ import ( "fmt" "os" + "github.com/bisaxa/bitreader" "github.com/bisaxa/demoparser/classes" "github.com/bisaxa/demoparser/utils" ) -const MSSC int32 = 2 - func ParseMessage(file *os.File) (statusCode int) { - var message Message - message.Type = utils.ReadByteFromFile(file, 1)[0] - message.Tick = int(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - message.Slot = utils.ReadByteFromFile(file, 1)[0] - switch message.Type { + reader := bitreader.Reader(file, true) + messageType := reader.TryReadInt8() + messageTick := reader.TryReadInt32() + messageSlot := reader.TryReadInt8() + fmt.Println(messageType, messageTick, messageSlot) + switch messageType { case 0x01: // SignOn var packet Packet - // var cmdinfo classes.CmdInfo - packet.PacketInfo = utils.ReadByteFromFile(file, 76*MSSC) - packet.InSequence = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.OutSequence = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.Data = utils.ReadByteFromFile(file, packet.Size) - // cmdinfo = classes.CmdInfoInit(packet.PacketInfo) - // fmt.Println(cmdinfo) + packet.PacketInfo = classes.ParseCmdInfo(file, 2) + packet.InSequence = int32(reader.TryReadInt32()) + packet.OutSequence = int32(reader.TryReadInt32()) + packet.Size = int32(reader.TryReadInt32()) + reader.SkipBytes(int(packet.Size)) return 1 case 0x02: // Packet var packet Packet - // var cmdinfo classes.CmdInfo - packet.PacketInfo = utils.ReadByteFromFile(file, 76*MSSC) - packet.InSequence = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.OutSequence = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - packet.Data = utils.ReadByteFromFile(file, packet.Size) - // cmdinfo = classes.CmdInfoInit(packet.PacketInfo) - // fmt.Printf("[%d] %v\n", utils.IntFromBytes(Tick), cmdinfo) + packet.PacketInfo = classes.ParseCmdInfo(file, 2) + packet.InSequence = int32(reader.TryReadInt32()) + packet.OutSequence = int32(reader.TryReadInt32()) + packet.Size = int32(reader.TryReadInt32()) + reader.SkipBytes(int(packet.Size)) return 2 case 0x03: // SyncTick return 3 - case 0x04: // Consolecmd + case 0x04: // ConsoleCmd var consolecmd ConsoleCmd - consolecmd.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) + consolecmd.Size = int32(reader.TryReadInt32()) consolecmd.Data = string(utils.ReadByteFromFile(file, consolecmd.Size)) - //fmt.Printf("[%d] %s\n", message.Tick, consolecmd.Data) return 4 - case 0x05: // Usercmd + case 0x05: // UserCmd var usercmd UserCmd - var usercmdinfo classes.UserCmdInfo - usercmd.Cmd = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - usercmd.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - usercmd.Data = utils.ReadByteFromFile(file, usercmd.Size) - usercmdinfo = classes.UserCmdInfoInit(usercmd.Data, usercmd.Size) - fmt.Printf("[%d] UserCmd: %v\n", message.Tick, usercmdinfo) + usercmd.Cmd = int32(reader.TryReadInt32()) + usercmd.Size = int32(reader.TryReadInt32()) + usercmd.Data = classes.ParseUserCmdInfo(file, int(usercmd.Size)) return 5 case 0x06: // DataTables var datatables DataTables - //var stringtable classes.StringTable - datatables.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - datatables.Data = utils.ReadByteFromFile(file, datatables.Size) - // stringtable = classes.StringTableInit(Data) - // fmt.Printf("[%d] DataTables: %v\n", utils.IntFromBytes(Size), stringtable) + datatables.Size = int32(reader.TryReadInt32()) + reader.SkipBytes(int(datatables.Size)) return 6 case 0x07: // Stop - fmt.Println("Stop - End of Demo") return 7 case 0x08: // CustomData var customdata CustomData - customdata.Unknown = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - customdata.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - customdata.Data = utils.ReadByteFromFile(file, customdata.Size) + customdata.Unknown = int32(reader.TryReadInt32()) + customdata.Size = int32(reader.TryReadInt32()) + reader.SkipBytes(int(customdata.Size)) return 8 case 0x09: // StringTables var stringtables StringTables - stringtables.Size = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - stringtables.Data = utils.ReadByteFromFile(file, stringtables.Size) + stringtables.Size = int32(reader.TryReadInt32()) + reader.SkipBytes(int(stringtables.Size)) return 9 default: return 0 } - -} - -func ParseHeader(file *os.File) { - var header Header - header.DemoFileStamp = string(utils.ReadByteFromFile(file, 8)) - header.DemoProtocol = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - header.NetworkProtocol = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - header.ServerName = string(utils.ReadByteFromFile(file, 260)) - header.ClientName = string(utils.ReadByteFromFile(file, 260)) - header.MapName = string(utils.ReadByteFromFile(file, 260)) - header.GameDirectory = string(utils.ReadByteFromFile(file, 260)) - header.PlaybackTime = float32(utils.FloatFromBytes(utils.ReadByteFromFile(file, 4))) - header.PlaybackTicks = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - header.PlaybackFrames = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - header.SignOnLength = int32(utils.IntFromBytes(utils.ReadByteFromFile(file, 4))) - fmt.Println(header) } diff --git a/messages/types.go b/messages/types.go index bb19444..a1d51a8 100644 --- a/messages/types.go +++ b/messages/types.go @@ -1,5 +1,7 @@ package messages +import "github.com/bisaxa/demoparser/classes" + type Header struct { DemoFileStamp string DemoProtocol int32 @@ -14,14 +16,8 @@ type Header struct { SignOnLength int32 } -type Message struct { - Type byte - Tick int - Slot byte -} - type Packet struct { - PacketInfo []byte + PacketInfo []classes.CmdInfo InSequence int32 OutSequence int32 Size int32 @@ -36,7 +32,7 @@ type ConsoleCmd struct { type UserCmd struct { Cmd int32 Size int32 - Data []byte + Data classes.UserCmdInfo } type DataTables struct { diff --git a/utils/bitreader.go b/utils/bitreader.go deleted file mode 100644 index ec7454e..0000000 --- a/utils/bitreader.go +++ /dev/null @@ -1,94 +0,0 @@ -package utils - -import ( - "fmt" - "math" - "strconv" -) - -func ReadButtonsDataFromInt32(input int32) []string { - buttonList := [32]string{ - "Attack", - "Jump", - "Duck", - "Forward", - "Back", - "Use", - "Cancel", - "Left", - "Right", - "MoveLeft", - "MoveRight", - "Attack2", - "Run", - "Reload", - "Alt1", - "Alt2", - "Score", - "Speed", - "Walk", - "Zoom", - "Weapon1", - "Weapon2", - "BullRush", - "Grenade1", - "Grenade2", - "LookSpin", - "CurrentAbility", - "PreviousAbility", - "Ability1", - "Ability2", - "Ability3", - "Ability4", - } - var buttons []string - if input == 0 { - buttons = append(buttons, buttonList[0]) - return buttons - } - for i := 1; i < 33; i++ { - if ReadBitState(input, i) { - buttons = append(buttons, buttonList[i]) - } - } - return buttons -} - -func ReadBitState(input int32, index int) bool { - value := input & (1 << index) - return value > 0 -} - -func ReadBitStateLSB(input byte, index int) (bool, error) { - if index < 0 && index > 7 { - return false, fmt.Errorf("IndexOutOfBounds for type byte") - } - value := input & (1 << index) - return (value > 0), nil -} - -func Read32BitsAfterFirstBitInt32(input []byte, index int, step int) int32 { - binary := "" - binary += fmt.Sprintf("%08b", input[step])[8-index : 8] - binary += fmt.Sprintf("%08b", input[step-1]) - binary += fmt.Sprintf("%08b", input[step-2]) - binary += fmt.Sprintf("%08b", input[step-3]) - binary += fmt.Sprintf("%08b", input[step-4])[:8-index] - output, err := strconv.ParseInt(binary, 2, 32) - CheckError(err) - return int32(output) - -} - -func Read32BitsAfterFirstBitFloat32(input []byte, index int, step int) float32 { - binary := "" - binary += fmt.Sprintf("%08b", input[step])[8-index : 8] - binary += fmt.Sprintf("%08b", input[step-1]) - binary += fmt.Sprintf("%08b", input[step-2]) - binary += fmt.Sprintf("%08b", input[step-3]) - binary += fmt.Sprintf("%08b", input[step-4])[:8-index] - output, err := strconv.ParseUint(binary, 2, 32) - CheckError(err) - return math.Float32frombits(uint32(output)) - -} diff --git a/utils/utils.go b/utils/utils.go index 5226e80..46b707c 100644 --- a/utils/utils.go +++ b/utils/utils.go @@ -1,55 +1,15 @@ package utils -import ( - "encoding/binary" - "log" - "math" - "math/bits" - "os" - "unsafe" -) +import "os" func CheckError(e error) { if e != nil { - log.Panic(e) + panic(e) } } -func ReverseByteArrayValues(byteArr []byte, size int) []byte { - arr := make([]byte, size) - for index, byteValue := range byteArr { - arr[index] = bits.Reverse8(byteValue) - } - return arr -} - func ReadByteFromFile(file *os.File, size int32) []byte { tmp := make([]byte, size) file.Read(tmp) return tmp } - -func IntFromBytes(byteArr []byte) uint32 { - int := binary.LittleEndian.Uint32(byteArr) - return int -} - -func FloatFromBytes(byteArr []byte) float32 { - bits := binary.LittleEndian.Uint32(byteArr) - float := math.Float32frombits(bits) - return float -} - -func FloatArrFromBytes(byteArr []byte) []float32 { - if len(byteArr) == 0 { - return nil - } - - l := len(byteArr) / 4 - ptr := unsafe.Pointer(&byteArr[0]) - // It is important to keep in mind that the Go garbage collector - // will not interact with this data, and that if src if freed, - // the behavior of any Go code using the slice is nondeterministic. - // Reference: https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices - return (*[1 << 26]float32)((*[1 << 26]float32)(ptr))[:l:l] -} -- cgit v1.2.3