cleanup function layout for decoders

internal/decoders/data_packet_chunk.go

@@ -10,24 +10,30 @@ type DataPacketChunkData struct {
 	TrackerList  *DataTrackerListChunk
 }
 
-func decodeDataPacketChunkData(dataPacketChunk Chunk) DataPacketChunkData {
+type DataPacketChunk struct {
+	Chunk Chunk
+	Data  DataPacketChunkData
+}
+
+func DecodeDataPacketChunk(bytes []byte) DataPacketChunk {
+	chunk := DecodeChunk(bytes)
 	data := DataPacketChunkData{}
 
-	if dataPacketChunk.Header.HasSubchunks && dataPacketChunk.ChunkData != nil && dataPacketChunk.Header.DataLen > 0 {
+	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
 
-		for offset < int(dataPacketChunk.Header.DataLen) {
+		for offset < int(chunk.Header.DataLen) {
 
-			switch id := binary.LittleEndian.Uint16(dataPacketChunk.ChunkData[offset : offset+2]); id {
+			switch id := binary.LittleEndian.Uint16(chunk.ChunkData[offset : offset+2]); id {
 			case 0:
-				packet_header := DecodePacketHeaderChunk(dataPacketChunk.ChunkData[offset:])
+				packet_header := DecodePacketHeaderChunk(chunk.ChunkData[offset:])
 				data.PacketHeader = &packet_header
 				offset += 4
 				if packet_header.Chunk.Header.DataLen > 0 {
 					offset = offset + int(packet_header.Chunk.Header.DataLen)
 				}
 			case 1:
-				tracker_list := DecodeDataTrackerListChunk(dataPacketChunk.ChunkData[offset:])
+				tracker_list := DecodeDataTrackerListChunk(chunk.ChunkData[offset:])
 				data.TrackerList = &tracker_list
 				offset += 4
 				if tracker_list.Chunk.Header.DataLen > 0 {
@@ -39,17 +45,6 @@ func decodeDataPacketChunkData(dataPacketChunk Chunk) DataPacketChunkData {
 			}
 		}
 	}
-	return data
-}
-
-type DataPacketChunk struct {
-	Chunk Chunk
-	Data  DataPacketChunkData
-}
-
-func DecodeDataPacketChunk(bytes []byte) DataPacketChunk {
-	chunk := DecodeChunk(bytes)
-	data := decodeDataPacketChunkData(chunk)
 
 	return DataPacketChunk{
 		Chunk: chunk,

internal/decoders/data_tracker_chunk.go

@@ -15,74 +15,6 @@ type DataTrackerChunkData struct {
 	Timestamp *DataTrackerTimestampChunk
 }
 
-func decodeDataTrackerChunkData(dataTrackerChunk Chunk) DataTrackerChunkData {
-
-	data := DataTrackerChunkData{}
-
-	if dataTrackerChunk.Header.HasSubchunks && dataTrackerChunk.ChunkData != nil && dataTrackerChunk.Header.DataLen > 0 {
-		offset := 0
-
-		for offset < int(dataTrackerChunk.Header.DataLen) {
-
-			switch id := binary.LittleEndian.Uint16(dataTrackerChunk.ChunkData[offset : offset+2]); id {
-			case 0:
-				pos := DecodeDataTrackerXYZChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Pos = &pos
-				offset += 4
-				if data.Pos.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Pos.Chunk.Header.DataLen)
-				}
-			case 1:
-				speed := DecodeDataTrackerXYZChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Speed = &speed
-				offset += 4
-				if data.Speed.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Speed.Chunk.Header.DataLen)
-				}
-			case 2:
-				ori := DecodeDataTrackerXYZChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Ori = &ori
-				offset += 4
-				if data.Ori.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Ori.Chunk.Header.DataLen)
-				}
-			case 3:
-				status := DecodeDataTrackerStatusChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Status = &status
-				offset += 4
-				if data.Status.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Status.Chunk.Header.DataLen)
-				}
-			case 4:
-				accel := DecodeDataTrackerXYZChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Accel = &accel
-				offset += 4
-				if data.Accel.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Accel.Chunk.Header.DataLen)
-				}
-			case 5:
-				trgtpos := DecodeDataTrackerXYZChunk(dataTrackerChunk.ChunkData[offset:])
-				data.TrgtPos = &trgtpos
-				offset += 4
-				if data.TrgtPos.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.TrgtPos.Chunk.Header.DataLen)
-				}
-			case 6:
-				timestamp := DecodeDataTrackerTimestampChunk(dataTrackerChunk.ChunkData[offset:])
-				data.Timestamp = &timestamp
-				offset += 4
-				if data.Timestamp.Chunk.Header.DataLen > 0 {
-					offset = offset + int(data.Timestamp.Chunk.Header.DataLen)
-				}
-			default:
-				offset = int(dataTrackerChunk.Header.DataLen)
-				slog.Error("unhandled data tracker packet chunk id", "id", id)
-			}
-		}
-	}
-	return data
-}
-
 type DataTrackerChunk struct {
 	Chunk Chunk
 	Data  DataTrackerChunkData
@@ -90,7 +22,69 @@ type DataTrackerChunk struct {
 
 func DecodeDataTrackerChunk(bytes []byte) DataTrackerChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeDataTrackerChunkData(chunk)
+	data := DataTrackerChunkData{}
+
+	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
+		offset := 0
+
+		for offset < int(chunk.Header.DataLen) {
+
+			switch id := binary.LittleEndian.Uint16(chunk.ChunkData[offset : offset+2]); id {
+			case 0:
+				pos := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
+				data.Pos = &pos
+				offset += 4
+				if data.Pos.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Pos.Chunk.Header.DataLen)
+				}
+			case 1:
+				speed := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
+				data.Speed = &speed
+				offset += 4
+				if data.Speed.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Speed.Chunk.Header.DataLen)
+				}
+			case 2:
+				ori := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
+				data.Ori = &ori
+				offset += 4
+				if data.Ori.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Ori.Chunk.Header.DataLen)
+				}
+			case 3:
+				status := DecodeDataTrackerStatusChunk(chunk.ChunkData[offset:])
+				data.Status = &status
+				offset += 4
+				if data.Status.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Status.Chunk.Header.DataLen)
+				}
+			case 4:
+				accel := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
+				data.Accel = &accel
+				offset += 4
+				if data.Accel.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Accel.Chunk.Header.DataLen)
+				}
+			case 5:
+				trgtpos := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
+				data.TrgtPos = &trgtpos
+				offset += 4
+				if data.TrgtPos.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.TrgtPos.Chunk.Header.DataLen)
+				}
+			case 6:
+				timestamp := DecodeDataTrackerTimestampChunk(chunk.ChunkData[offset:])
+				data.Timestamp = &timestamp
+				offset += 4
+				if data.Timestamp.Chunk.Header.DataLen > 0 {
+					offset = offset + int(data.Timestamp.Chunk.Header.DataLen)
+				}
+			default:
+				offset = int(chunk.Header.DataLen)
+				slog.Error("unhandled data tracker packet chunk id", "id", id)
+			}
+		}
+	}
 
 	return DataTrackerChunk{
 		Chunk: chunk,

internal/decoders/data_tracker_list_chunk.go

@@ -3,13 +3,19 @@ package decoders
 type DataTrackerListChunkData struct {
 	Trackers []DataTrackerChunk
 }
+type DataTrackerListChunk struct {
+	Chunk Chunk
+	Data  DataTrackerListChunkData
+}
 
-func decodeDataTrackerListChunkData(dataTrackerListChunk Chunk) DataTrackerListChunkData {
+func DecodeDataTrackerListChunk(bytes []byte) DataTrackerListChunk {
-	var trackers []DataTrackerChunk
+	chunk := DecodeChunk(bytes)
-	if dataTrackerListChunk.Header.HasSubchunks && dataTrackerListChunk.Header.DataLen > 0 {
+
+	trackers := []DataTrackerChunk{}
+	if chunk.Header.HasSubchunks && chunk.Header.DataLen > 0 {
 		offset := 0
-		for offset < int(dataTrackerListChunk.Header.DataLen) {
+		for offset < int(chunk.Header.DataLen) {
-			trackerChunk := DecodeDataTrackerChunk(dataTrackerListChunk.ChunkData[offset:])
+			trackerChunk := DecodeDataTrackerChunk(chunk.ChunkData[offset:])
 			offset += 4
 			if trackerChunk.Chunk.Header.DataLen > 0 {
 				offset += int(trackerChunk.Chunk.Header.DataLen)
@@ -18,19 +24,9 @@ func decodeDataTrackerListChunkData(dataTrackerListChunk Chunk) DataTrackerListC
 		}
 	}
 
-	return DataTrackerListChunkData{
+	data := DataTrackerListChunkData{
 		Trackers: trackers,
 	}
-}
-
-type DataTrackerListChunk struct {
-	Chunk Chunk
-	Data  DataTrackerListChunkData
-}
-
-func DecodeDataTrackerListChunk(bytes []byte) DataTrackerListChunk {
-	chunk := DecodeChunk(bytes)
-	data := decodeDataTrackerListChunkData(chunk)
 
 	return DataTrackerListChunk{
 		Chunk: chunk,

internal/decoders/data_tracker_status_chunk.go

@@ -9,14 +9,6 @@ type DataTrackerStatusChunkData struct {
 	Validity float32
 }
 
-func decodeDataTrackerStatusChunk(dataTrackerStatusChunk Chunk) DataTrackerStatusChunkData {
-	statusBits := binary.LittleEndian.Uint32(dataTrackerStatusChunk.ChunkData[0:4])
-
-	return DataTrackerStatusChunkData{
-		Validity: math.Float32frombits(statusBits),
-	}
-}
-
 type DataTrackerStatusChunk struct {
 	Chunk Chunk
 	Data  DataTrackerStatusChunkData
@@ -24,7 +16,12 @@ type DataTrackerStatusChunk struct {
 
 func DecodeDataTrackerStatusChunk(bytes []byte) DataTrackerStatusChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeDataTrackerStatusChunk(chunk)
+
+	statusBits := binary.LittleEndian.Uint32(chunk.ChunkData[0:4])
+
+	data := DataTrackerStatusChunkData{
+		Validity: math.Float32frombits(statusBits),
+	}
 
 	return DataTrackerStatusChunk{
 		Chunk: chunk,

internal/decoders/data_tracker_timestamp_chunk.go

@@ -8,14 +8,6 @@ type DataTrackerTimestampChunkData struct {
 	Timestamp uint64
 }
 
-func decodeDataTrackerTimestampChunk(dataTrackerTimestampChunk Chunk) DataTrackerTimestampChunkData {
-	timestamp := binary.LittleEndian.Uint64(dataTrackerTimestampChunk.ChunkData[0:8])
-
-	return DataTrackerTimestampChunkData{
-		Timestamp: timestamp,
-	}
-}
-
 type DataTrackerTimestampChunk struct {
 	Chunk Chunk
 	Data  DataTrackerTimestampChunkData
@@ -23,7 +15,12 @@ type DataTrackerTimestampChunk struct {
 
 func DecodeDataTrackerTimestampChunk(bytes []byte) DataTrackerTimestampChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeDataTrackerTimestampChunk(chunk)
+
+	timestamp := binary.LittleEndian.Uint64(chunk.ChunkData[0:8])
+
+	data := DataTrackerTimestampChunkData{
+		Timestamp: timestamp,
+	}
 
 	return DataTrackerTimestampChunk{
 		Chunk: chunk,

internal/decoders/data_tracker_xyz_chunk.go

@@ -11,18 +11,6 @@ type DataTrackerXYZChunkData struct {
 	Z float32
 }
 
-func decodeDataTrackerXYZChunk(dataTrackerXYZChunk Chunk) DataTrackerXYZChunkData {
-	xBits := binary.LittleEndian.Uint32(dataTrackerXYZChunk.ChunkData[0:4])
-	yBits := binary.LittleEndian.Uint32(dataTrackerXYZChunk.ChunkData[4:8])
-	zBits := binary.LittleEndian.Uint32(dataTrackerXYZChunk.ChunkData[8:12])
-
-	return DataTrackerXYZChunkData{
-		X: math.Float32frombits(xBits),
-		Y: math.Float32frombits(yBits),
-		Z: math.Float32frombits(zBits),
-	}
-}
-
 type DataTrackerXYZChunk struct {
 	Chunk Chunk
 	Data  DataTrackerXYZChunkData
@@ -30,7 +18,16 @@ type DataTrackerXYZChunk struct {
 
 func DecodeDataTrackerXYZChunk(bytes []byte) DataTrackerXYZChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeDataTrackerXYZChunk(chunk)
+
+	xBits := binary.LittleEndian.Uint32(chunk.ChunkData[0:4])
+	yBits := binary.LittleEndian.Uint32(chunk.ChunkData[4:8])
+	zBits := binary.LittleEndian.Uint32(chunk.ChunkData[8:12])
+
+	data := DataTrackerXYZChunkData{
+		X: math.Float32frombits(xBits),
+		Y: math.Float32frombits(yBits),
+		Z: math.Float32frombits(zBits),
+	}
 
 	return DataTrackerXYZChunk{
 		Chunk: chunk,

internal/decoders/info_packet_chunk.go

@@ -11,31 +11,37 @@ type InfoPacketChunkData struct {
 	TrackerList  *InfoTrackerListChunk
 }
 
-func decodeInfoPacketChunkData(infoPacketChunk Chunk) InfoPacketChunkData {
+type InfoPacketChunk struct {
+	Chunk Chunk
+	Data  InfoPacketChunkData
+}
+
+func DecodeInfoPacketChunk(bytes []byte) InfoPacketChunk {
+	chunk := DecodeChunk(bytes)
 	data := InfoPacketChunkData{}
 
-	if infoPacketChunk.Header.HasSubchunks && infoPacketChunk.ChunkData != nil && infoPacketChunk.Header.DataLen > 0 {
+	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
 
-		for offset < int(infoPacketChunk.Header.DataLen) {
+		for offset < int(chunk.Header.DataLen) {
 
-			switch id := binary.LittleEndian.Uint16(infoPacketChunk.ChunkData[offset : offset+2]); id {
+			switch id := binary.LittleEndian.Uint16(chunk.ChunkData[offset : offset+2]); id {
 			case 0:
-				packet_header := DecodePacketHeaderChunk(infoPacketChunk.ChunkData[offset:])
+				packet_header := DecodePacketHeaderChunk(chunk.ChunkData[offset:])
 				data.PacketHeader = &packet_header
 				offset += 4
 				if packet_header.Chunk.Header.DataLen > 0 {
 					offset = offset + int(packet_header.Chunk.Header.DataLen)
 				}
 			case 1:
-				system_name := DecodeInfoSystemNameChunk(infoPacketChunk.ChunkData[offset:])
+				system_name := DecodeInfoSystemNameChunk(chunk.ChunkData[offset:])
 				data.SystemName = &system_name
 				offset += 4
 				if system_name.Chunk.Header.DataLen > 0 {
 					offset = offset + int(system_name.Chunk.Header.DataLen)
 				}
 			case 2:
-				tracker_list := DecodeInfoTrackerListChunk(infoPacketChunk.ChunkData[offset:])
+				tracker_list := DecodeInfoTrackerListChunk(chunk.ChunkData[offset:])
 				data.TrackerList = &tracker_list
 				offset += 4
 				if tracker_list.Chunk.Header.DataLen > 0 {
@@ -47,17 +53,6 @@ func decodeInfoPacketChunkData(infoPacketChunk Chunk) InfoPacketChunkData {
 			}
 		}
 	}
-	return data
-}
-
-type InfoPacketChunk struct {
-	Chunk Chunk
-	Data  InfoPacketChunkData
-}
-
-func DecodeInfoPacketChunk(bytes []byte) InfoPacketChunk {
-	chunk := DecodeChunk(bytes)
-	data := decodeInfoPacketChunkData(chunk)
 
 	return InfoPacketChunk{
 		Chunk: chunk,

internal/decoders/info_system_name_chunk.go

@@ -4,14 +4,6 @@ type InfoSystemNameChunkData struct {
 	SystemName string
 }
 
-func decodeInfoSystemNameChunkData(infoSystemNameChunk Chunk) InfoSystemNameChunkData {
-	system_name := string(infoSystemNameChunk.ChunkData[0:infoSystemNameChunk.Header.DataLen])
-
-	return InfoSystemNameChunkData{
-		SystemName: system_name,
-	}
-}
-
 type InfoSystemNameChunk struct {
 	Chunk Chunk
 	Data  InfoSystemNameChunkData
@@ -19,7 +11,11 @@ type InfoSystemNameChunk struct {
 
 func DecodeInfoSystemNameChunk(bytes []byte) InfoSystemNameChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeInfoSystemNameChunkData(chunk)
+	system_name := string(chunk.ChunkData[0:chunk.Header.DataLen])
+
+	data := InfoSystemNameChunkData{
+		SystemName: system_name,
+	}
 
 	return InfoSystemNameChunk{
 		Chunk: chunk,

internal/decoders/info_tracker_chunk.go

@@ -9,17 +9,23 @@ type InfoTrackerChunkData struct {
 	TrackerName *InfoTrackerNameChunk
 }
 
-func decodeInfoTrackerChunkData(infoTrackerChunk Chunk) InfoTrackerChunkData {
+type InfoTrackerChunk struct {
+	Chunk Chunk
+	Data  InfoTrackerChunkData
+}
+
+func DecodeInfoTrackerChunk(bytes []byte) InfoTrackerChunk {
+	chunk := DecodeChunk(bytes)
 	data := InfoTrackerChunkData{}
 
-	if infoTrackerChunk.Header.HasSubchunks && infoTrackerChunk.ChunkData != nil && infoTrackerChunk.Header.DataLen > 0 {
+	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
 
-		for offset < int(infoTrackerChunk.Header.DataLen) {
+		for offset < int(chunk.Header.DataLen) {
 
-			switch id := binary.LittleEndian.Uint16(infoTrackerChunk.ChunkData[offset : offset+2]); id {
+			switch id := binary.LittleEndian.Uint16(chunk.ChunkData[offset : offset+2]); id {
 			case 0:
-				tracker_name := DecodeInfoTrackerNameChunk(infoTrackerChunk.ChunkData[offset:])
+				tracker_name := DecodeInfoTrackerNameChunk(chunk.ChunkData[offset:])
 				data.TrackerName = &tracker_name
 				offset += 4
 				if tracker_name.Chunk.Header.DataLen > 0 {
@@ -30,17 +36,6 @@ func decodeInfoTrackerChunkData(infoTrackerChunk Chunk) InfoTrackerChunkData {
 			}
 		}
 	}
-	return data
-}
-
-type InfoTrackerChunk struct {
-	Chunk Chunk
-	Data  InfoTrackerChunkData
-}
-
-func DecodeInfoTrackerChunk(bytes []byte) InfoTrackerChunk {
-	chunk := DecodeChunk(bytes)
-	data := decodeInfoTrackerChunkData(chunk)
 
 	return InfoTrackerChunk{
 		Chunk: chunk,

internal/decoders/info_tracker_list_chunk.go

@@ -4,25 +4,6 @@ type InfoTrackerListChunkData struct {
 	Trackers []InfoTrackerChunk
 }
 
-func decodeInfoTrackerListChunkData(infoTrackerListChunk Chunk) InfoTrackerListChunkData {
-	var trackers []InfoTrackerChunk
-	if infoTrackerListChunk.Header.HasSubchunks && infoTrackerListChunk.Header.DataLen > 0 {
-		offset := 0
-		for offset < int(infoTrackerListChunk.Header.DataLen) {
-			trackerChunk := DecodeInfoTrackerChunk(infoTrackerListChunk.ChunkData[offset:])
-			offset += 4
-			if trackerChunk.Chunk.Header.DataLen > 0 {
-				offset += int(trackerChunk.Chunk.Header.DataLen)
-			}
-			trackers = append(trackers, trackerChunk)
-		}
-	}
-
-	return InfoTrackerListChunkData{
-		Trackers: trackers,
-	}
-}
-
 type InfoTrackerListChunk struct {
 	Chunk Chunk
 	Data  InfoTrackerListChunkData
@@ -30,7 +11,23 @@ type InfoTrackerListChunk struct {
 
 func DecodeInfoTrackerListChunk(bytes []byte) InfoTrackerListChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeInfoTrackerListChunkData(chunk)
+
+	trackers := []InfoTrackerChunk{}
+	if chunk.Header.HasSubchunks && chunk.Header.DataLen > 0 {
+		offset := 0
+		for offset < int(chunk.Header.DataLen) {
+			trackerChunk := DecodeInfoTrackerChunk(chunk.ChunkData[offset:])
+			offset += 4
+			if trackerChunk.Chunk.Header.DataLen > 0 {
+				offset += int(trackerChunk.Chunk.Header.DataLen)
+			}
+			trackers = append(trackers, trackerChunk)
+		}
+	}
+
+	data := InfoTrackerListChunkData{
+		Trackers: trackers,
+	}
 
 	return InfoTrackerListChunk{
 		Chunk: chunk,

internal/decoders/info_tracker_name_chunk.go

@@ -4,14 +4,6 @@ type InfoTrackerNameChunkData struct {
 	TrackerName string
 }
 
-func decodeInfoTrackerNameChunkData(infoTrackerNameChunk Chunk) InfoTrackerNameChunkData {
-	tracker_name := string(infoTrackerNameChunk.ChunkData[0:infoTrackerNameChunk.Header.DataLen])
-
-	return InfoTrackerNameChunkData{
-		TrackerName: tracker_name,
-	}
-}
-
 type InfoTrackerNameChunk struct {
 	Chunk Chunk
 	Data  InfoTrackerNameChunkData
@@ -19,7 +11,12 @@ type InfoTrackerNameChunk struct {
 
 func DecodeInfoTrackerNameChunk(bytes []byte) InfoTrackerNameChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodeInfoTrackerNameChunkData(chunk)
+
+	tracker_name := string(chunk.ChunkData[0:chunk.Header.DataLen])
+
+	data := InfoTrackerNameChunkData{
+		TrackerName: tracker_name,
+	}
 
 	return InfoTrackerNameChunk{
 		Chunk: chunk,

internal/decoders/packet_header_chunk.go

@@ -10,22 +10,6 @@ type PacketHeaderChunkData struct {
 	FramePacketCount uint8
 }
 
-func decodePacketHeaderChunkData(packetHeaderChunk Chunk) PacketHeaderChunkData {
-	packet_timestamp := binary.LittleEndian.Uint64(packetHeaderChunk.ChunkData[0:8])
-	version_high := packetHeaderChunk.ChunkData[8]
-	version_low := packetHeaderChunk.ChunkData[9]
-	frame_id := packetHeaderChunk.ChunkData[10]
-	frame_packet_count := packetHeaderChunk.ChunkData[11]
-
-	return PacketHeaderChunkData{
-		PacketTimestamp:  packet_timestamp,
-		VersionHigh:      version_high,
-		VersionLow:       version_low,
-		FrameId:          frame_id,
-		FramePacketCount: frame_packet_count,
-	}
-}
-
 type PacketHeaderChunk struct {
 	Chunk Chunk
 	Data  PacketHeaderChunkData
@@ -33,7 +17,20 @@ type PacketHeaderChunk struct {
 
 func DecodePacketHeaderChunk(bytes []byte) PacketHeaderChunk {
 	chunk := DecodeChunk(bytes)
-	data := decodePacketHeaderChunkData(chunk)
+
+	packet_timestamp := binary.LittleEndian.Uint64(chunk.ChunkData[0:8])
+	version_high := chunk.ChunkData[8]
+	version_low := chunk.ChunkData[9]
+	frame_id := chunk.ChunkData[10]
+	frame_packet_count := chunk.ChunkData[11]
+
+	data := PacketHeaderChunkData{
+		PacketTimestamp:  packet_timestamp,
+		VersionHigh:      version_high,
+		VersionLow:       version_low,
+		FrameId:          frame_id,
+		FramePacketCount: frame_packet_count,
+	}
 
 	return PacketHeaderChunk{
 		Chunk: chunk,