move types out of decoders package

decoder.go

@@ -1,27 +1,28 @@
 package psn
 
 import (
+	"github.com/jwetzell/psn-go/internal/chunks"
 	"github.com/jwetzell/psn-go/internal/decoders"
 )
 
 type Decoder struct {
-	lastInfoPacketHeader *decoders.PacketHeaderChunk
+	lastInfoPacketHeader *chunks.PacketHeaderChunk
-	lastDataPacketHeader *decoders.PacketHeaderChunk
+	lastDataPacketHeader *chunks.PacketHeaderChunk
-	infoPacketFrames     map[uint8][]decoders.InfoPacketChunk
+	infoPacketFrames     map[uint8][]chunks.InfoPacketChunk
-	dataPacketFrames     map[uint8][]decoders.DataPacketChunk
+	dataPacketFrames     map[uint8][]chunks.DataPacketChunk
 	Trackers             map[uint16]*Tracker
 	SystemName           string
 }
 
 func NewDecoder() *Decoder {
 	var decoder Decoder
-	decoder.infoPacketFrames = map[uint8][]decoders.InfoPacketChunk{}
+	decoder.infoPacketFrames = map[uint8][]chunks.InfoPacketChunk{}
-	decoder.dataPacketFrames = map[uint8][]decoders.DataPacketChunk{}
+	decoder.dataPacketFrames = map[uint8][]chunks.DataPacketChunk{}
 	decoder.Trackers = map[uint16]*Tracker{}
 	return &decoder
 }
 
-func (d *Decoder) updateInfo(framePackets []decoders.InfoPacketChunk) {
+func (d *Decoder) updateInfo(framePackets []chunks.InfoPacketChunk) {
 	for _, framePacket := range framePackets {
 		d.SystemName = framePacket.Data.SystemName.Data.SystemName
 		for _, infoTrackerChunk := range framePacket.Data.TrackerList.Data.Trackers {
@@ -36,7 +37,7 @@ func (d *Decoder) updateInfo(framePackets []decoders.InfoPacketChunk) {
 	}
 }
 
-func (d *Decoder) updateData(framePackets []decoders.DataPacketChunk) {
+func (d *Decoder) updateData(framePackets []chunks.DataPacketChunk) {
 	for _, framePacket := range framePackets {
 		for _, dataTrackerChunk := range framePacket.Data.TrackerList.Data.Trackers {
 			tracker, ok := d.Trackers[dataTrackerChunk.Chunk.Header.Id]
@@ -67,7 +68,7 @@ func (d *Decoder) Decode(bytes []byte) error {
 		_, ok := d.infoPacketFrames[currentInfoPacketHeader.Data.FrameId]
 
 		if !ok {
-			d.infoPacketFrames[currentInfoPacketHeader.Data.FrameId] = []decoders.InfoPacketChunk{}
+			d.infoPacketFrames[currentInfoPacketHeader.Data.FrameId] = []chunks.InfoPacketChunk{}
 		}
 		d.infoPacketFrames[currentInfoPacketHeader.Data.FrameId] = append(d.infoPacketFrames[currentInfoPacketHeader.Data.FrameId], infoPacket)
 
@@ -85,7 +86,7 @@ func (d *Decoder) Decode(bytes []byte) error {
 		_, ok := d.dataPacketFrames[currentInfoPacketHeader.Data.FrameId]
 
 		if !ok {
-			d.dataPacketFrames[currentInfoPacketHeader.Data.FrameId] = []decoders.DataPacketChunk{}
+			d.dataPacketFrames[currentInfoPacketHeader.Data.FrameId] = []chunks.DataPacketChunk{}
 		}
 		d.dataPacketFrames[currentInfoPacketHeader.Data.FrameId] = append(d.dataPacketFrames[currentInfoPacketHeader.Data.FrameId], dataPacket)
 

internal/chunks/chunk.go

@@ -0,0 +1,12 @@
+package chunks
+
+type ChunkHeader struct {
+	Id           uint16
+	DataLen      uint16
+	HasSubchunks bool
+}
+
+type Chunk struct {
+	ChunkData []byte
+	Header    ChunkHeader
+}

internal/chunks/data_packet_chunk.go

@@ -0,0 +1,11 @@
+package chunks
+
+type DataPacketChunkData struct {
+	PacketHeader *PacketHeaderChunk
+	TrackerList  *DataTrackerListChunk
+}
+
+type DataPacketChunk struct {
+	Data  DataPacketChunkData
+	Chunk Chunk
+}

internal/chunks/data_tracker_chunk.go

@@ -0,0 +1,16 @@
+package chunks
+
+type DataTrackerChunkData struct {
+	Pos       *DataTrackerXYZChunk
+	Speed     *DataTrackerXYZChunk
+	Ori       *DataTrackerXYZChunk
+	Status    *DataTrackerStatusChunk
+	Accel     *DataTrackerXYZChunk
+	TrgtPos   *DataTrackerXYZChunk
+	Timestamp *DataTrackerTimestampChunk
+}
+
+type DataTrackerChunk struct {
+	Data  DataTrackerChunkData
+	Chunk Chunk
+}

internal/chunks/data_tracker_list_chunk.go

@@ -0,0 +1,9 @@
+package chunks
+
+type DataTrackerListChunkData struct {
+	Trackers []DataTrackerChunk
+}
+type DataTrackerListChunk struct {
+	Chunk Chunk
+	Data  DataTrackerListChunkData
+}

internal/chunks/data_tracker_status_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type DataTrackerStatusChunkData struct {
+	Validity float32
+}
+
+type DataTrackerStatusChunk struct {
+	Chunk Chunk
+	Data  DataTrackerStatusChunkData
+}

internal/chunks/data_tracker_timestamp_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type DataTrackerTimestampChunkData struct {
+	Timestamp uint64
+}
+
+type DataTrackerTimestampChunk struct {
+	Chunk Chunk
+	Data  DataTrackerTimestampChunkData
+}

internal/chunks/data_tracker_xyz_chunk.go

@@ -0,0 +1,12 @@
+package chunks
+
+type DataTrackerXYZChunkData struct {
+	X float32
+	Y float32
+	Z float32
+}
+
+type DataTrackerXYZChunk struct {
+	Chunk Chunk
+	Data  DataTrackerXYZChunkData
+}

internal/chunks/info_packet_chunk.go

@@ -0,0 +1,12 @@
+package chunks
+
+type InfoPacketChunkData struct {
+	PacketHeader *PacketHeaderChunk
+	SystemName   *InfoSystemNameChunk
+	TrackerList  *InfoTrackerListChunk
+}
+
+type InfoPacketChunk struct {
+	Data  InfoPacketChunkData
+	Chunk Chunk
+}

internal/chunks/info_system_name_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type InfoSystemNameChunkData struct {
+	SystemName string
+}
+
+type InfoSystemNameChunk struct {
+	Data  InfoSystemNameChunkData
+	Chunk Chunk
+}

internal/chunks/info_tracker_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type InfoTrackerChunkData struct {
+	TrackerName *InfoTrackerNameChunk
+}
+
+type InfoTrackerChunk struct {
+	Data  InfoTrackerChunkData
+	Chunk Chunk
+}

internal/chunks/info_tracker_list_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type InfoTrackerListChunkData struct {
+	Trackers []InfoTrackerChunk
+}
+
+type InfoTrackerListChunk struct {
+	Chunk Chunk
+	Data  InfoTrackerListChunkData
+}

internal/chunks/info_tracker_name_chunk.go

@@ -0,0 +1,10 @@
+package chunks
+
+type InfoTrackerNameChunkData struct {
+	TrackerName string
+}
+
+type InfoTrackerNameChunk struct {
+	Data  InfoTrackerNameChunkData
+	Chunk Chunk
+}

internal/chunks/packet_header_chunk.go

@@ -0,0 +1,14 @@
+package chunks
+
+type PacketHeaderChunkData struct {
+	PacketTimestamp  uint64
+	VersionHigh      uint8
+	VersionLow       uint8
+	FrameId          uint8
+	FramePacketCount uint8
+}
+
+type PacketHeaderChunk struct {
+	Chunk Chunk
+	Data  PacketHeaderChunkData
+}

internal/decoders/chunk.go

@@ -3,23 +3,14 @@ package decoders
 import (
 	"encoding/binary"
 	"errors"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type ChunkHeader struct {
+func DecodeChunk(bytes []byte) (chunks.Chunk, error) {
-	Id           uint16
-	DataLen      uint16
-	HasSubchunks bool
-}
-
-type Chunk struct {
-	ChunkData []byte
-	Header    ChunkHeader
-}
-
-func DecodeChunk(bytes []byte) (Chunk, error) {
 
 	if len(bytes) < 4 {
-		return Chunk{}, errors.New("chunk must be at least 4 bytes")
+		return chunks.Chunk{}, errors.New("chunk must be at least 4 bytes")
 	}
 
 	id := binary.LittleEndian.Uint16(bytes[0:2])
@@ -33,7 +24,7 @@ func DecodeChunk(bytes []byte) (Chunk, error) {
 		data_len = data_len - 32768
 	}
 
-	header := ChunkHeader{
+	header := chunks.ChunkHeader{
 		Id:           id,
 		DataLen:      data_len,
 		HasSubchunks: has_subchunks,
@@ -41,7 +32,7 @@ func DecodeChunk(bytes []byte) (Chunk, error) {
 
 	chunk_data := bytes[4 : 4+header.DataLen]
 
-	return Chunk{
+	return chunks.Chunk{
 		Header:    header,
 		ChunkData: chunk_data,
 	}, nil

internal/decoders/chunk_test.go

@@ -5,13 +5,15 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    Chunk
+		expected    chunks.Chunk
 	}{
 		{
 			description: "info packet",
@@ -20,8 +22,8 @@ func TestGoodChunkDecoding(t *testing.T) {
 				0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11,
 				0x80, 0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x31,
 			},
-			expected: Chunk{
+			expected: chunks.Chunk{
-				Header: ChunkHeader{
+				Header: chunks.ChunkHeader{
 					Id:           uint16(26454),
 					DataLen:      uint16(52),
 					HasSubchunks: true,
@@ -40,8 +42,8 @@ func TestGoodChunkDecoding(t *testing.T) {
 				0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
 				0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f,
 			},
-			expected: Chunk{
+			expected: chunks.Chunk{
-				Header: ChunkHeader{
+				Header: chunks.ChunkHeader{
 					Id:           uint16(26453),
 					DataLen:      uint16(40),
 					HasSubchunks: true,

internal/decoders/data_packet_chunk.go

@@ -3,26 +3,18 @@ package decoders
 import (
 	"encoding/binary"
 	"log/slog"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type DataPacketChunkData struct {
+func DecodeDataPacketChunk(bytes []byte) (chunks.DataPacketChunk, error) {
-	PacketHeader *PacketHeaderChunk
-	TrackerList  *DataTrackerListChunk
-}
-
-type DataPacketChunk struct {
-	Data  DataPacketChunkData
-	Chunk Chunk
-}
-
-func DecodeDataPacketChunk(bytes []byte) (DataPacketChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataPacketChunk{}, err
+		return chunks.DataPacketChunk{}, err
 	}
 
-	data := DataPacketChunkData{}
+	data := chunks.DataPacketChunkData{}
 
 	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
@@ -32,7 +24,7 @@ func DecodeDataPacketChunk(bytes []byte) (DataPacketChunk, error) {
 			case 0x0000:
 				packet_header, err := DecodePacketHeaderChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataPacketChunk{}, err
+					return chunks.DataPacketChunk{}, err
 				}
 				data.PacketHeader = &packet_header
 				offset += 4
@@ -42,7 +34,7 @@ func DecodeDataPacketChunk(bytes []byte) (DataPacketChunk, error) {
 			case 0x0001:
 				tracker_list, err := DecodeDataTrackerListChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataPacketChunk{}, err
+					return chunks.DataPacketChunk{}, err
 				}
 				data.TrackerList = &tracker_list
 				offset += 4
@@ -56,7 +48,7 @@ func DecodeDataPacketChunk(bytes []byte) (DataPacketChunk, error) {
 		}
 	}
 
-	return DataPacketChunk{
+	return chunks.DataPacketChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/data_packet_chunk_test.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataPacketChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataPacketChunk
+		expected    chunks.DataPacketChunk
 	}{
 		{
 			description: "DataPacketChunk",
@@ -20,25 +22,25 @@ func TestGoodDataPacketChunkDecoding(t *testing.T) {
 				0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
 				0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 			},
-			expected: DataPacketChunk{
+			expected: chunks.DataPacketChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{
 						0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0,
 						128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0,
 						128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0,
 						64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 					},
-					Header: ChunkHeader{
+					Header: chunks.ChunkHeader{
 						DataLen: 124, Id: 26453, HasSubchunks: true,
 					},
 				},
-				Data: DataPacketChunkData{
+				Data: chunks.DataPacketChunkData{
-					PacketHeader: &PacketHeaderChunk{
+					PacketHeader: &chunks.PacketHeaderChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123},
-							Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 						},
-						Data: PacketHeaderChunkData{
+						Data: chunks.PacketHeaderChunkData{
 							PacketTimestamp:  1234567890,
 							VersionHigh:      2,
 							VersionLow:       3,
@@ -46,99 +48,99 @@ func TestGoodDataPacketChunkDecoding(t *testing.T) {
 							FramePacketCount: 123,
 						},
 					},
-					TrackerList: &DataTrackerListChunk{
+					TrackerList: &chunks.DataTrackerListChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{
 								1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0,
 								0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4,
 								0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 								6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 							},
-							Header: ChunkHeader{DataLen: 104, Id: 1, HasSubchunks: true},
+							Header: chunks.ChunkHeader{DataLen: 104, Id: 1, HasSubchunks: true},
 						},
-						Data: DataTrackerListChunkData{
+						Data: chunks.DataTrackerListChunkData{
-							Trackers: []DataTrackerChunk{
+							Trackers: []chunks.DataTrackerChunk{
-								DataTrackerChunk{
+								chunks.DataTrackerChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{
 											0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
 											0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
 											12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64,
 											64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 										},
-										Header: ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
+										Header: chunks.ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
 									},
-									Data: DataTrackerChunkData{
+									Data: chunks.DataTrackerChunkData{
-										Pos: &DataTrackerXYZChunk{
+										Pos: &chunks.DataTrackerXYZChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-												Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 											},
-											Data: DataTrackerXYZChunkData{
+											Data: chunks.DataTrackerXYZChunkData{
 												X: 1.0,
 												Y: 2.0,
 												Z: 3.0,
 											},
 										},
-										Speed: &DataTrackerXYZChunk{
+										Speed: &chunks.DataTrackerXYZChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-												Header:    ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
 											},
-											Data: DataTrackerXYZChunkData{
+											Data: chunks.DataTrackerXYZChunkData{
 												X: 1.0,
 												Y: 2.0,
 												Z: 3.0,
 											},
 										},
-										Ori: &DataTrackerXYZChunk{
+										Ori: &chunks.DataTrackerXYZChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-												Header:    ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
 											},
-											Data: DataTrackerXYZChunkData{
+											Data: chunks.DataTrackerXYZChunkData{
 												X: 1.0,
 												Y: 2.0,
 												Z: 3.0,
 											},
 										},
-										Status: &DataTrackerStatusChunk{
+										Status: &chunks.DataTrackerStatusChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63},
-												Header:    ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
 											},
-											Data: DataTrackerStatusChunkData{
+											Data: chunks.DataTrackerStatusChunkData{
 												Validity: 1.0,
 											},
 										},
-										Accel: &DataTrackerXYZChunk{
+										Accel: &chunks.DataTrackerXYZChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-												Header:    ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
 											},
-											Data: DataTrackerXYZChunkData{
+											Data: chunks.DataTrackerXYZChunkData{
 												X: 1.0,
 												Y: 2.0,
 												Z: 3.0,
 											},
 										},
-										TrgtPos: &DataTrackerXYZChunk{
+										TrgtPos: &chunks.DataTrackerXYZChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-												Header:    ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
 											},
-											Data: DataTrackerXYZChunkData{
+											Data: chunks.DataTrackerXYZChunkData{
 												X: 1.0,
 												Y: 2.0,
 												Z: 3.0,
 											},
 										},
-										Timestamp: &DataTrackerTimestampChunk{
+										Timestamp: &chunks.DataTrackerTimestampChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0},
-												Header:    ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
 											},
-											Data: DataTrackerTimestampChunkData{
+											Data: chunks.DataTrackerTimestampChunkData{
 												Timestamp: 1234567890,
 											},
 										},

internal/decoders/data_tracker_chunk.go

@@ -3,31 +3,18 @@ package decoders
 import (
 	"encoding/binary"
 	"log/slog"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type DataTrackerChunkData struct {
+func DecodeDataTrackerChunk(bytes []byte) (chunks.DataTrackerChunk, error) {
-	Pos       *DataTrackerXYZChunk
-	Speed     *DataTrackerXYZChunk
-	Ori       *DataTrackerXYZChunk
-	Status    *DataTrackerStatusChunk
-	Accel     *DataTrackerXYZChunk
-	TrgtPos   *DataTrackerXYZChunk
-	Timestamp *DataTrackerTimestampChunk
-}
-
-type DataTrackerChunk struct {
-	Data  DataTrackerChunkData
-	Chunk Chunk
-}
-
-func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataTrackerChunk{}, err
+		return chunks.DataTrackerChunk{}, err
 	}
 
-	data := DataTrackerChunkData{}
+	data := chunks.DataTrackerChunkData{}
 
 	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
@@ -37,7 +24,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0000:
 				pos, err := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Pos = &pos
 				offset += 4
@@ -47,7 +34,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0001:
 				speed, err := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Speed = &speed
 				offset += 4
@@ -57,7 +44,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0002:
 				ori, err := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Ori = &ori
 				offset += 4
@@ -67,7 +54,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0003:
 				status, err := DecodeDataTrackerStatusChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Status = &status
 				offset += 4
@@ -77,7 +64,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0004:
 				accel, err := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Accel = &accel
 				offset += 4
@@ -87,7 +74,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0005:
 				trgtpos, err := DecodeDataTrackerXYZChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.TrgtPos = &trgtpos
 				offset += 4
@@ -97,7 +84,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 			case 0x0006:
 				timestamp, err := DecodeDataTrackerTimestampChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return DataTrackerChunk{}, err
+					return chunks.DataTrackerChunk{}, err
 				}
 				data.Timestamp = &timestamp
 				offset += 4
@@ -111,7 +98,7 @@ func DecodeDataTrackerChunk(bytes []byte) (DataTrackerChunk, error) {
 		}
 	}
 
-	return DataTrackerChunk{
+	return chunks.DataTrackerChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/data_tracker_chunk_test.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataTrackerChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataTrackerChunk
+		expected    chunks.DataTrackerChunk
 	}{
 		{
 			description: "DataTracker",
@@ -19,87 +21,87 @@ func TestGoodDataTrackerChunkDecoding(t *testing.T) {
 				0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
 				0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 			},
-			expected: DataTrackerChunk{
+			expected: chunks.DataTrackerChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{
 						0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
 						0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
 						12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64,
 						64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 					},
-					Header: ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
+					Header: chunks.ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
 				},
-				Data: DataTrackerChunkData{
+				Data: chunks.DataTrackerChunkData{
-					Pos: &DataTrackerXYZChunk{
+					Pos: &chunks.DataTrackerXYZChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-							Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 						},
-						Data: DataTrackerXYZChunkData{
+						Data: chunks.DataTrackerXYZChunkData{
 							X: 1.0,
 							Y: 2.0,
 							Z: 3.0,
 						},
 					},
-					Speed: &DataTrackerXYZChunk{
+					Speed: &chunks.DataTrackerXYZChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-							Header:    ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
 						},
-						Data: DataTrackerXYZChunkData{
+						Data: chunks.DataTrackerXYZChunkData{
 							X: 1.0,
 							Y: 2.0,
 							Z: 3.0,
 						},
 					},
-					Ori: &DataTrackerXYZChunk{
+					Ori: &chunks.DataTrackerXYZChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-							Header:    ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
 						},
-						Data: DataTrackerXYZChunkData{
+						Data: chunks.DataTrackerXYZChunkData{
 							X: 1.0,
 							Y: 2.0,
 							Z: 3.0,
 						},
 					},
-					Status: &DataTrackerStatusChunk{
+					Status: &chunks.DataTrackerStatusChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63},
-							Header:    ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
 						},
-						Data: DataTrackerStatusChunkData{
+						Data: chunks.DataTrackerStatusChunkData{
 							Validity: 1.0,
 						},
 					},
-					Accel: &DataTrackerXYZChunk{
+					Accel: &chunks.DataTrackerXYZChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-							Header:    ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
 						},
-						Data: DataTrackerXYZChunkData{
+						Data: chunks.DataTrackerXYZChunkData{
 							X: 1.0,
 							Y: 2.0,
 							Z: 3.0,
 						},
 					},
-					TrgtPos: &DataTrackerXYZChunk{
+					TrgtPos: &chunks.DataTrackerXYZChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-							Header:    ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
 						},
-						Data: DataTrackerXYZChunkData{
+						Data: chunks.DataTrackerXYZChunkData{
 							X: 1.0,
 							Y: 2.0,
 							Z: 3.0,
 						},
 					},
-					Timestamp: &DataTrackerTimestampChunk{
+					Timestamp: &chunks.DataTrackerTimestampChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0},
-							Header:    ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
 						},
-						Data: DataTrackerTimestampChunkData{
+						Data: chunks.DataTrackerTimestampChunkData{
 							Timestamp: 1234567890,
 						},
 					},

internal/decoders/data_tracker_list_chunk.go

@@ -1,27 +1,21 @@
 package decoders
 
-type DataTrackerListChunkData struct {
+import "github.com/jwetzell/psn-go/internal/chunks"
-	Trackers []DataTrackerChunk
-}
-type DataTrackerListChunk struct {
-	Chunk Chunk
-	Data  DataTrackerListChunkData
-}
 
-func DecodeDataTrackerListChunk(bytes []byte) (DataTrackerListChunk, error) {
+func DecodeDataTrackerListChunk(bytes []byte) (chunks.DataTrackerListChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataTrackerListChunk{}, err
+		return chunks.DataTrackerListChunk{}, err
 	}
 
-	trackers := []DataTrackerChunk{}
+	trackers := []chunks.DataTrackerChunk{}
 	if chunk.Header.HasSubchunks && chunk.Header.DataLen > 0 {
 		offset := 0
 		for offset < int(chunk.Header.DataLen) {
 			trackerChunk, err := DecodeDataTrackerChunk(chunk.ChunkData[offset:])
 			if err != nil {
-				return DataTrackerListChunk{}, err
+				return chunks.DataTrackerListChunk{}, err
 			}
 			offset += 4
 			if trackerChunk.Chunk.Header.DataLen > 0 {
@@ -31,11 +25,11 @@ func DecodeDataTrackerListChunk(bytes []byte) (DataTrackerListChunk, error) {
 		}
 	}
 
-	data := DataTrackerListChunkData{
+	data := chunks.DataTrackerListChunkData{
 		Trackers: trackers,
 	}
 
-	return DataTrackerListChunk{
+	return chunks.DataTrackerListChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/data_tracker_list_chunk_test.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataTrackerListChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataTrackerListChunk
+		expected    chunks.DataTrackerListChunk
 	}{
 		{
 			description: "DataTrackerListChunk",
@@ -19,99 +21,99 @@ func TestGoodDataTrackerListChunkDecoding(t *testing.T) {
 				64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128,
 				63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 			},
-			expected: DataTrackerListChunk{
+			expected: chunks.DataTrackerListChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{
 						1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0,
 						0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4,
 						0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 						6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 					},
-					Header: ChunkHeader{DataLen: 104, Id: 1, HasSubchunks: true},
+					Header: chunks.ChunkHeader{DataLen: 104, Id: 1, HasSubchunks: true},
 				},
-				Data: DataTrackerListChunkData{
+				Data: chunks.DataTrackerListChunkData{
-					Trackers: []DataTrackerChunk{
+					Trackers: []chunks.DataTrackerChunk{
 						{
-							Chunk: Chunk{
+							Chunk: chunks.Chunk{
 								ChunkData: []byte{
 									0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
 									0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
 									12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64,
 									64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 								},
-								Header: ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
+								Header: chunks.ChunkHeader{DataLen: 100, Id: 1, HasSubchunks: true},
 							},
-							Data: DataTrackerChunkData{
+							Data: chunks.DataTrackerChunkData{
-								Pos: &DataTrackerXYZChunk{
+								Pos: &chunks.DataTrackerXYZChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-										Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 									},
-									Data: DataTrackerXYZChunkData{
+									Data: chunks.DataTrackerXYZChunkData{
 										X: 1.0,
 										Y: 2.0,
 										Z: 3.0,
 									},
 								},
-								Speed: &DataTrackerXYZChunk{
+								Speed: &chunks.DataTrackerXYZChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-										Header:    ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
 									},
-									Data: DataTrackerXYZChunkData{
+									Data: chunks.DataTrackerXYZChunkData{
 										X: 1.0,
 										Y: 2.0,
 										Z: 3.0,
 									},
 								},
-								Ori: &DataTrackerXYZChunk{
+								Ori: &chunks.DataTrackerXYZChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-										Header:    ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
 									},
-									Data: DataTrackerXYZChunkData{
+									Data: chunks.DataTrackerXYZChunkData{
 										X: 1.0,
 										Y: 2.0,
 										Z: 3.0,
 									},
 								},
-								Status: &DataTrackerStatusChunk{
+								Status: &chunks.DataTrackerStatusChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63},
-										Header:    ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
 									},
-									Data: DataTrackerStatusChunkData{
+									Data: chunks.DataTrackerStatusChunkData{
 										Validity: 1.0,
 									},
 								},
-								Accel: &DataTrackerXYZChunk{
+								Accel: &chunks.DataTrackerXYZChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-										Header:    ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
 									},
-									Data: DataTrackerXYZChunkData{
+									Data: chunks.DataTrackerXYZChunkData{
 										X: 1.0,
 										Y: 2.0,
 										Z: 3.0,
 									},
 								},
-								TrgtPos: &DataTrackerXYZChunk{
+								TrgtPos: &chunks.DataTrackerXYZChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-										Header:    ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
 									},
-									Data: DataTrackerXYZChunkData{
+									Data: chunks.DataTrackerXYZChunkData{
 										X: 1.0,
 										Y: 2.0,
 										Z: 3.0,
 									},
 								},
-								Timestamp: &DataTrackerTimestampChunk{
+								Timestamp: &chunks.DataTrackerTimestampChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0},
-										Header:    ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
 									},
-									Data: DataTrackerTimestampChunkData{
+									Data: chunks.DataTrackerTimestampChunkData{
 										Timestamp: 1234567890,
 									},
 								},

internal/decoders/data_tracker_status_chunk.go

@@ -4,35 +4,28 @@ import (
 	"encoding/binary"
 	"errors"
 	"math"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type DataTrackerStatusChunkData struct {
+func DecodeDataTrackerStatusChunk(bytes []byte) (chunks.DataTrackerStatusChunk, error) {
-	Validity float32
-}
-
-type DataTrackerStatusChunk struct {
-	Chunk Chunk
-	Data  DataTrackerStatusChunkData
-}
-
-func DecodeDataTrackerStatusChunk(bytes []byte) (DataTrackerStatusChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataTrackerStatusChunk{}, err
+		return chunks.DataTrackerStatusChunk{}, err
 	}
 
 	if len(chunk.ChunkData) < 4 {
-		return DataTrackerStatusChunk{}, errors.New("DATA_TRACKER_STATUS chunk must be at least 4 bytes")
+		return chunks.DataTrackerStatusChunk{}, errors.New("DATA_TRACKER_STATUS chunk must be at least 4 bytes")
 	}
 
 	statusBits := binary.LittleEndian.Uint32(chunk.ChunkData[0:4])
 
-	data := DataTrackerStatusChunkData{
+	data := chunks.DataTrackerStatusChunkData{
 		Validity: math.Float32frombits(statusBits),
 	}
 
-	return DataTrackerStatusChunk{
+	return chunks.DataTrackerStatusChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/data_tracker_status_chunk_test.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataTrackerStatusChunk(t *testing.T) {
@@ -11,17 +13,17 @@ func TestGoodDataTrackerStatusChunk(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataTrackerStatusChunk
+		expected    chunks.DataTrackerStatusChunk
 	}{
 		{
 			description: "DataTrackerStatusChunk",
 			bytes:       []byte{3, 0, 4, 0, 0, 0, 128, 63},
-			expected: DataTrackerStatusChunk{
+			expected: chunks.DataTrackerStatusChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63},
-					Header:    ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 4, Id: 3, HasSubchunks: false},
 				},
-				Data: DataTrackerStatusChunkData{
+				Data: chunks.DataTrackerStatusChunkData{
 					Validity: 1.0,
 				},
 			},

internal/decoders/data_tracker_timestamp_chunk.go

@@ -3,35 +3,28 @@ package decoders
 import (
 	"encoding/binary"
 	"errors"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type DataTrackerTimestampChunkData struct {
+func DecodeDataTrackerTimestampChunk(bytes []byte) (chunks.DataTrackerTimestampChunk, error) {
-	Timestamp uint64
-}
-
-type DataTrackerTimestampChunk struct {
-	Chunk Chunk
-	Data  DataTrackerTimestampChunkData
-}
-
-func DecodeDataTrackerTimestampChunk(bytes []byte) (DataTrackerTimestampChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataTrackerTimestampChunk{}, err
+		return chunks.DataTrackerTimestampChunk{}, err
 	}
 
 	if len(chunk.ChunkData) < 8 {
-		return DataTrackerTimestampChunk{}, errors.New("DATA_TRACKER_TIMESTAMP chunk must be at least 8 bytes")
+		return chunks.DataTrackerTimestampChunk{}, errors.New("DATA_TRACKER_TIMESTAMP chunk must be at least 8 bytes")
 	}
 
 	timestamp := binary.LittleEndian.Uint64(chunk.ChunkData[0:8])
 
-	data := DataTrackerTimestampChunkData{
+	data := chunks.DataTrackerTimestampChunkData{
 		Timestamp: timestamp,
 	}
 
-	return DataTrackerTimestampChunk{
+	return chunks.DataTrackerTimestampChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/data_tracker_timestamp_chunk_test.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataTrackerTimestampChunk(t *testing.T) {
@@ -11,17 +13,17 @@ func TestGoodDataTrackerTimestampChunk(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataTrackerTimestampChunk
+		expected    chunks.DataTrackerTimestampChunk
 	}{
 		{
 			description: "DataTrackerTimestampChunk",
 			bytes:       []byte{6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0},
-			expected: DataTrackerTimestampChunk{
+			expected: chunks.DataTrackerTimestampChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0},
-					Header:    ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 8, Id: 6, HasSubchunks: false},
 				},
-				Data: DataTrackerTimestampChunkData{
+				Data: chunks.DataTrackerTimestampChunkData{
 					Timestamp: 1234567890,
 				},
 			},

internal/decoders/data_tracker_xyz_chunk.go

@@ -4,41 +4,32 @@ import (
 	"encoding/binary"
 	"errors"
 	"math"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type DataTrackerXYZChunkData struct {
+func DecodeDataTrackerXYZChunk(bytes []byte) (chunks.DataTrackerXYZChunk, error) {
-	X float32
-	Y float32
-	Z float32
-}
-
-type DataTrackerXYZChunk struct {
-	Chunk Chunk
-	Data  DataTrackerXYZChunkData
-}
-
-func DecodeDataTrackerXYZChunk(bytes []byte) (DataTrackerXYZChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return DataTrackerXYZChunk{}, err
+		return chunks.DataTrackerXYZChunk{}, err
 	}
 
 	if len(chunk.ChunkData) < 12 {
-		return DataTrackerXYZChunk{}, errors.New("DATA_TRACKER_XYZ chunk must be at least 12 bytes")
+		return chunks.DataTrackerXYZChunk{}, errors.New("DATA_TRACKER_XYZ chunk must be at least 12 bytes")
 	}
 
 	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{
+	data := chunks.DataTrackerXYZChunkData{
 		X: math.Float32frombits(xBits),
 		Y: math.Float32frombits(yBits),
 		Z: math.Float32frombits(zBits),
 	}
 
-	return DataTrackerXYZChunk{
+	return chunks.DataTrackerXYZChunk{
 		Chunk: chunk,
 		Data:  data,
 	}, nil

internal/decoders/data_tracker_xyz_chunk_test.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodDataTrackerXYZChunk(t *testing.T) {
@@ -11,17 +13,17 @@ func TestGoodDataTrackerXYZChunk(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    DataTrackerXYZChunk
+		expected    chunks.DataTrackerXYZChunk
 	}{
 		{
 			description: "DataTrackerPosChunk",
 			bytes:       []byte{0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-			expected: DataTrackerXYZChunk{
+			expected: chunks.DataTrackerXYZChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-					Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 				},
-				Data: DataTrackerXYZChunkData{
+				Data: chunks.DataTrackerXYZChunkData{
 					X: 1.0,
 					Y: 2.0,
 					Z: 3.0,
@@ -31,12 +33,12 @@ func TestGoodDataTrackerXYZChunk(t *testing.T) {
 		{
 			description: "DataTrackerSpeedChunk",
 			bytes:       []byte{1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-			expected: DataTrackerXYZChunk{
+			expected: chunks.DataTrackerXYZChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-					Header:    ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 1, HasSubchunks: false},
 				},
-				Data: DataTrackerXYZChunkData{
+				Data: chunks.DataTrackerXYZChunkData{
 					X: 1.0,
 					Y: 2.0,
 					Z: 3.0,
@@ -46,12 +48,12 @@ func TestGoodDataTrackerXYZChunk(t *testing.T) {
 		{
 			description: "DataTrackerOriChunk",
 			bytes:       []byte{2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-			expected: DataTrackerXYZChunk{
+			expected: chunks.DataTrackerXYZChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-					Header:    ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 2, HasSubchunks: false},
 				},
-				Data: DataTrackerXYZChunkData{
+				Data: chunks.DataTrackerXYZChunkData{
 					X: 1.0,
 					Y: 2.0,
 					Z: 3.0,
@@ -61,12 +63,12 @@ func TestGoodDataTrackerXYZChunk(t *testing.T) {
 		{
 			description: "DataTrackerAccelChunk",
 			bytes:       []byte{4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-			expected: DataTrackerXYZChunk{
+			expected: chunks.DataTrackerXYZChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-					Header:    ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 4, HasSubchunks: false},
 				},
-				Data: DataTrackerXYZChunkData{
+				Data: chunks.DataTrackerXYZChunkData{
 					X: 1.0,
 					Y: 2.0,
 					Z: 3.0,
@@ -76,12 +78,12 @@ func TestGoodDataTrackerXYZChunk(t *testing.T) {
 		{
 			description: "DataTrackerTrgtPosChunk",
 			bytes:       []byte{5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-			expected: DataTrackerXYZChunk{
+			expected: chunks.DataTrackerXYZChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64},
-					Header:    ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 5, HasSubchunks: false},
 				},
-				Data: DataTrackerXYZChunkData{
+				Data: chunks.DataTrackerXYZChunkData{
 					X: 1.0,
 					Y: 2.0,
 					Z: 3.0,

internal/decoders/info_packet_chunk.go

@@ -3,25 +3,16 @@ package decoders
 import (
 	"encoding/binary"
 	"log/slog"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type InfoPacketChunkData struct {
+func DecodeInfoPacketChunk(bytes []byte) (chunks.InfoPacketChunk, error) {
-	PacketHeader *PacketHeaderChunk
-	SystemName   *InfoSystemNameChunk
-	TrackerList  *InfoTrackerListChunk
-}
-
-type InfoPacketChunk struct {
-	Data  InfoPacketChunkData
-	Chunk Chunk
-}
-
-func DecodeInfoPacketChunk(bytes []byte) (InfoPacketChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 	if err != nil {
-		return InfoPacketChunk{}, err
+		return chunks.InfoPacketChunk{}, err
 	}
-	data := InfoPacketChunkData{}
+	data := chunks.InfoPacketChunkData{}
 
 	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
@@ -31,7 +22,7 @@ func DecodeInfoPacketChunk(bytes []byte) (InfoPacketChunk, error) {
 			case 0x0000:
 				packet_header, err := DecodePacketHeaderChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return InfoPacketChunk{}, err
+					return chunks.InfoPacketChunk{}, err
 				}
 				data.PacketHeader = &packet_header
 				offset += 4
@@ -41,7 +32,7 @@ func DecodeInfoPacketChunk(bytes []byte) (InfoPacketChunk, error) {
 			case 0x0001:
 				system_name, err := DecodeInfoSystemNameChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return InfoPacketChunk{}, err
+					return chunks.InfoPacketChunk{}, err
 				}
 				data.SystemName = &system_name
 				offset += 4
@@ -51,7 +42,7 @@ func DecodeInfoPacketChunk(bytes []byte) (InfoPacketChunk, error) {
 			case 0x0002:
 				tracker_list, err := DecodeInfoTrackerListChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return InfoPacketChunk{}, err
+					return chunks.InfoPacketChunk{}, err
 				}
 				data.TrackerList = &tracker_list
 				offset += 4
@@ -65,7 +56,7 @@ func DecodeInfoPacketChunk(bytes []byte) (InfoPacketChunk, error) {
 		}
 	}
 
-	return InfoPacketChunk{
+	return chunks.InfoPacketChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/info_packet_chunk_test.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodInfoPacketChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    InfoPacketChunk
+		expected    chunks.InfoPacketChunk
 	}{
 		{
 			description: "InfoPacketChunk",
@@ -18,21 +20,21 @@ func TestGoodInfoPacketChunkDecoding(t *testing.T) {
 				86, 103, 51, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101,
 				114, 118, 101, 114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			expected: InfoPacketChunk{
+			expected: chunks.InfoPacketChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{
 						0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101,
 						114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 					},
-					Header: ChunkHeader{DataLen: 51, Id: 26454, HasSubchunks: true},
+					Header: chunks.ChunkHeader{DataLen: 51, Id: 26454, HasSubchunks: true},
 				},
-				Data: InfoPacketChunkData{
+				Data: chunks.InfoPacketChunkData{
-					PacketHeader: &PacketHeaderChunk{
+					PacketHeader: &chunks.PacketHeaderChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123},
-							Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 						},
-						Data: PacketHeaderChunkData{
+						Data: chunks.PacketHeaderChunkData{
 							PacketTimestamp:  1234567890,
 							VersionHigh:      2,
 							VersionLow:       3,
@@ -40,34 +42,34 @@ func TestGoodInfoPacketChunkDecoding(t *testing.T) {
 							FramePacketCount: 123,
 						},
 					},
-					SystemName: &InfoSystemNameChunk{
+					SystemName: &chunks.InfoSystemNameChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{80, 83, 78, 32, 83, 101, 114, 118, 101, 114},
-							Header:    ChunkHeader{DataLen: 10, Id: 1, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 10, Id: 1, HasSubchunks: false},
 						},
-						Data: InfoSystemNameChunkData{
+						Data: chunks.InfoSystemNameChunkData{
 							SystemName: "PSN Server",
 						},
 					},
-					TrackerList: &InfoTrackerListChunk{
+					TrackerList: &chunks.InfoTrackerListChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-							Header:    ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
+							Header:    chunks.ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
 						},
-						Data: InfoTrackerListChunkData{
+						Data: chunks.InfoTrackerListChunkData{
-							Trackers: []InfoTrackerChunk{
+							Trackers: []chunks.InfoTrackerChunk{
 								{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-										Header:    ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
+										Header:    chunks.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
 									},
-									Data: InfoTrackerChunkData{
+									Data: chunks.InfoTrackerChunkData{
-										TrackerName: &InfoTrackerNameChunk{
+										TrackerName: &chunks.InfoTrackerNameChunk{
-											Chunk: Chunk{
+											Chunk: chunks.Chunk{
 												ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-												Header:    ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+												Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 											},
-											Data: InfoTrackerNameChunkData{
+											Data: chunks.InfoTrackerNameChunkData{
 												TrackerName: "Tracker 1",
 											},
 										},

internal/decoders/info_system_name_chunk.go

@@ -1,26 +1,19 @@
 package decoders
 
-type InfoSystemNameChunkData struct {
+import "github.com/jwetzell/psn-go/internal/chunks"
-	SystemName string
-}
 
-type InfoSystemNameChunk struct {
+func DecodeInfoSystemNameChunk(bytes []byte) (chunks.InfoSystemNameChunk, error) {
-	Data  InfoSystemNameChunkData
-	Chunk Chunk
-}
-
-func DecodeInfoSystemNameChunk(bytes []byte) (InfoSystemNameChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 	if err != nil {
-		return InfoSystemNameChunk{}, err
+		return chunks.InfoSystemNameChunk{}, err
 	}
-	data := InfoSystemNameChunkData{}
+	data := chunks.InfoSystemNameChunkData{}
 
 	if chunk.Header.DataLen > 0 {
 		data.SystemName = string(chunk.ChunkData[0:chunk.Header.DataLen])
 	}
 
-	return InfoSystemNameChunk{
+	return chunks.InfoSystemNameChunk{
 		Chunk: chunk,
 		Data:  data,
 	}, nil

internal/decoders/info_system_name_chunk_test.go

@@ -4,25 +4,27 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodInfoSystemNameChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    InfoSystemNameChunk
+		expected    chunks.InfoSystemNameChunk
 	}{
 		{
 			description: "InfoSystemNameChunk",
 			bytes: []byte{
 				1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114,
 			},
-			expected: InfoSystemNameChunk{
+			expected: chunks.InfoSystemNameChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{80, 83, 78, 32, 83, 101, 114, 118, 101, 114},
-					Header:    ChunkHeader{DataLen: 10, Id: 1, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 10, Id: 1, HasSubchunks: false},
 				},
-				Data: InfoSystemNameChunkData{
+				Data: chunks.InfoSystemNameChunkData{
 					SystemName: "PSN Server",
 				},
 			},

internal/decoders/info_tracker_chunk.go

@@ -3,23 +3,16 @@ package decoders
 import (
 	"encoding/binary"
 	"log/slog"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
-type InfoTrackerChunkData struct {
+func DecodeInfoTrackerChunk(bytes []byte) (chunks.InfoTrackerChunk, error) {
-	TrackerName *InfoTrackerNameChunk
-}
-
-type InfoTrackerChunk struct {
-	Data  InfoTrackerChunkData
-	Chunk Chunk
-}
-
-func DecodeInfoTrackerChunk(bytes []byte) (InfoTrackerChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 	if err != nil {
-		return InfoTrackerChunk{}, err
+		return chunks.InfoTrackerChunk{}, err
 	}
-	data := InfoTrackerChunkData{}
+	data := chunks.InfoTrackerChunkData{}
 
 	if chunk.Header.HasSubchunks && chunk.ChunkData != nil && chunk.Header.DataLen > 0 {
 		offset := 0
@@ -29,7 +22,7 @@ func DecodeInfoTrackerChunk(bytes []byte) (InfoTrackerChunk, error) {
 			case 0x0000:
 				tracker_name, err := DecodeInfoTrackerNameChunk(chunk.ChunkData[offset:])
 				if err != nil {
-					return InfoTrackerChunk{}, err
+					return chunks.InfoTrackerChunk{}, err
 				}
 				data.TrackerName = &tracker_name
 				offset += 4
@@ -42,7 +35,7 @@ func DecodeInfoTrackerChunk(bytes []byte) (InfoTrackerChunk, error) {
 		}
 	}
 
-	return InfoTrackerChunk{
+	return chunks.InfoTrackerChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/info_tracker_chunk_test.go

@@ -4,31 +4,33 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodInfoTrackerChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    InfoTrackerChunk
+		expected    chunks.InfoTrackerChunk
 	}{
 		{
 			description: "InfoTrackerChunk",
 			bytes: []byte{
 				1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			expected: InfoTrackerChunk{
+			expected: chunks.InfoTrackerChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-					Header:    ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
+					Header:    chunks.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
 				},
-				Data: InfoTrackerChunkData{
+				Data: chunks.InfoTrackerChunkData{
-					TrackerName: &InfoTrackerNameChunk{
+					TrackerName: &chunks.InfoTrackerNameChunk{
-						Chunk: Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-							Header:    ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 						},
-						Data: InfoTrackerNameChunkData{
+						Data: chunks.InfoTrackerNameChunkData{
 							TrackerName: "Tracker 1",
 						},
 					},

internal/decoders/info_tracker_list_chunk.go

@@ -1,27 +1,20 @@
 package decoders
 
-type InfoTrackerListChunkData struct {
+import "github.com/jwetzell/psn-go/internal/chunks"
-	Trackers []InfoTrackerChunk
-}
 
-type InfoTrackerListChunk struct {
+func DecodeInfoTrackerListChunk(bytes []byte) (chunks.InfoTrackerListChunk, error) {
-	Chunk Chunk
-	Data  InfoTrackerListChunkData
-}
-
-func DecodeInfoTrackerListChunk(bytes []byte) (InfoTrackerListChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 	if err != nil {
-		return InfoTrackerListChunk{}, err
+		return chunks.InfoTrackerListChunk{}, err
 	}
 
-	trackers := []InfoTrackerChunk{}
+	trackers := []chunks.InfoTrackerChunk{}
 	if chunk.Header.HasSubchunks && chunk.Header.DataLen > 0 {
 		offset := 0
 		for offset < int(chunk.Header.DataLen) {
 			trackerChunk, err := DecodeInfoTrackerChunk(chunk.ChunkData[offset:])
 			if err != nil {
-				return InfoTrackerListChunk{}, err
+				return chunks.InfoTrackerListChunk{}, err
 			}
 			offset += 4
 			if trackerChunk.Chunk.Header.DataLen > 0 {
@@ -31,11 +24,11 @@ func DecodeInfoTrackerListChunk(bytes []byte) (InfoTrackerListChunk, error) {
 		}
 	}
 
-	data := InfoTrackerListChunkData{
+	data := chunks.InfoTrackerListChunkData{
 		Trackers: trackers,
 	}
 
-	return InfoTrackerListChunk{
+	return chunks.InfoTrackerListChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/info_tracker_list_chunk_test.go

@@ -4,38 +4,40 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodInfoTrackerListChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    InfoTrackerListChunk
+		expected    chunks.InfoTrackerListChunk
 	}{
 		{
 			description: "InfoTrackerListChunk",
 			bytes: []byte{
 				2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			expected: InfoTrackerListChunk{
+			expected: chunks.InfoTrackerListChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-					Header:    ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
+					Header:    chunks.ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
 				},
-				Data: InfoTrackerListChunkData{
+				Data: chunks.InfoTrackerListChunkData{
-					Trackers: []InfoTrackerChunk{
+					Trackers: []chunks.InfoTrackerChunk{
 						{
-							Chunk: Chunk{
+							Chunk: chunks.Chunk{
 								ChunkData: []byte{0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-								Header:    ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
+								Header:    chunks.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
 							},
-							Data: InfoTrackerChunkData{
+							Data: chunks.InfoTrackerChunkData{
-								TrackerName: &InfoTrackerNameChunk{
+								TrackerName: &chunks.InfoTrackerNameChunk{
-									Chunk: Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-										Header:    ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 									},
-									Data: InfoTrackerNameChunkData{
+									Data: chunks.InfoTrackerNameChunkData{
 										TrackerName: "Tracker 1",
 									},
 								},

internal/decoders/info_tracker_name_chunk.go

@@ -1,28 +1,21 @@
 package decoders
 
-type InfoTrackerNameChunkData struct {
+import "github.com/jwetzell/psn-go/internal/chunks"
-	TrackerName string
-}
 
-type InfoTrackerNameChunk struct {
+func DecodeInfoTrackerNameChunk(bytes []byte) (chunks.InfoTrackerNameChunk, error) {
-	Data  InfoTrackerNameChunkData
-	Chunk Chunk
-}
-
-func DecodeInfoTrackerNameChunk(bytes []byte) (InfoTrackerNameChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 
 	if err != nil {
-		return InfoTrackerNameChunk{}, err
+		return chunks.InfoTrackerNameChunk{}, err
 	}
 
-	data := InfoTrackerNameChunkData{}
+	data := chunks.InfoTrackerNameChunkData{}
 
 	if chunk.Header.DataLen > 0 {
 		data.TrackerName = string(chunk.ChunkData[0:chunk.Header.DataLen])
 	}
 
-	return InfoTrackerNameChunk{
+	return chunks.InfoTrackerNameChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/info_tracker_name_chunk_test.go

@@ -4,25 +4,27 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodInfoTrackerNameChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    InfoTrackerNameChunk
+		expected    chunks.InfoTrackerNameChunk
 	}{
 		{
 			description: "InfoTrackerNameChunk",
 			bytes: []byte{
 				0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			expected: InfoTrackerNameChunk{
+			expected: chunks.InfoTrackerNameChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-					Header:    ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 				},
-				Data: InfoTrackerNameChunkData{
+				Data: chunks.InfoTrackerNameChunkData{
 					TrackerName: "Tracker 1",
 				},
 			},

internal/decoders/packet_header_chunk.go

@@ -1,24 +1,15 @@
 package decoders
 
-import "encoding/binary"
+import (
+	"encoding/binary"
 
-type PacketHeaderChunkData struct {
+	"github.com/jwetzell/psn-go/internal/chunks"
-	PacketTimestamp  uint64
+)
-	VersionHigh      uint8
-	VersionLow       uint8
-	FrameId          uint8
-	FramePacketCount uint8
-}
 
-type PacketHeaderChunk struct {
+func DecodePacketHeaderChunk(bytes []byte) (chunks.PacketHeaderChunk, error) {
-	Chunk Chunk
-	Data  PacketHeaderChunkData
-}
-
-func DecodePacketHeaderChunk(bytes []byte) (PacketHeaderChunk, error) {
 	chunk, err := DecodeChunk(bytes)
 	if err != nil {
-		return PacketHeaderChunk{}, err
+		return chunks.PacketHeaderChunk{}, err
 	}
 
 	packet_timestamp := binary.LittleEndian.Uint64(chunk.ChunkData[0:8])
@@ -27,7 +18,7 @@ func DecodePacketHeaderChunk(bytes []byte) (PacketHeaderChunk, error) {
 	frame_id := chunk.ChunkData[10]
 	frame_packet_count := chunk.ChunkData[11]
 
-	data := PacketHeaderChunkData{
+	data := chunks.PacketHeaderChunkData{
 		PacketTimestamp:  packet_timestamp,
 		VersionHigh:      version_high,
 		VersionLow:       version_low,
@@ -35,7 +26,7 @@ func DecodePacketHeaderChunk(bytes []byte) (PacketHeaderChunk, error) {
 		FramePacketCount: frame_packet_count,
 	}
 
-	return PacketHeaderChunk{
+	return chunks.PacketHeaderChunk{
 			Chunk: chunk,
 			Data:  data,
 		},

internal/decoders/packet_header_chunk_test.go

@@ -4,25 +4,27 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestGoodPacketHeaderChunkDecoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		bytes       []byte
-		expected    PacketHeaderChunk
+		expected    chunks.PacketHeaderChunk
 	}{
 		{
 			description: "PacketHeaderChunk",
 			bytes: []byte{
 				0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123,
 			},
-			expected: PacketHeaderChunk{
+			expected: chunks.PacketHeaderChunk{
-				Chunk: Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123},
-					Header:    ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
+					Header:    chunks.ChunkHeader{DataLen: 12, Id: 0, HasSubchunks: false},
 				},
-				Data: PacketHeaderChunkData{
+				Data: chunks.PacketHeaderChunkData{
 					PacketTimestamp:  1234567890,
 					VersionHigh:      2,
 					VersionLow:       3,

internal/encoders/chunk_test.go

@@ -5,14 +5,14 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		chunk       decoders.Chunk
+		chunk       chunks.Chunk
 	}{
 		{
 			description: "info packet",
@@ -21,8 +21,8 @@ func TestChunkEncoding(t *testing.T) {
 				0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11,
 				0x80, 0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x31,
 			},
-			chunk: decoders.Chunk{
+			chunk: chunks.Chunk{
-				Header: decoders.ChunkHeader{
+				Header: chunks.ChunkHeader{
 					Id:           uint16(26454),
 					DataLen:      uint16(52),
 					HasSubchunks: true,
@@ -41,8 +41,8 @@ func TestChunkEncoding(t *testing.T) {
 				0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
 				0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f,
 			},
-			chunk: decoders.Chunk{
+			chunk: chunks.Chunk{
-				Header: decoders.ChunkHeader{
+				Header: chunks.ChunkHeader{
 					Id:           uint16(26453),
 					DataLen:      uint16(40),
 					HasSubchunks: true,

internal/encoders/data_tracker_accel_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerAccelChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerXYZChunkData
+		data        chunks.DataTrackerXYZChunkData
 	}{
 		{
 			description: "basic acceleration",
 			expected: []byte{
 				4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 			},
-			data: decoders.DataTrackerXYZChunkData{
+			data: chunks.DataTrackerXYZChunkData{
 				X: 1,
 				Y: 2,
 				Z: 3,

internal/encoders/data_tracker_ori_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerOriChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerXYZChunkData
+		data        chunks.DataTrackerXYZChunkData
 	}{
 		{
 			description: "basic orientation",
 			expected: []byte{
 				2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 			},
-			data: decoders.DataTrackerXYZChunkData{
+			data: chunks.DataTrackerXYZChunkData{
 				X: 1,
 				Y: 2,
 				Z: 3,

internal/encoders/data_tracker_pos_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerPosChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerXYZChunkData
+		data        chunks.DataTrackerXYZChunkData
 	}{
 		{
 			description: "basic position",
 			expected: []byte{
 				0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 			},
-			data: decoders.DataTrackerXYZChunkData{
+			data: chunks.DataTrackerXYZChunkData{
 				X: 1,
 				Y: 2,
 				Z: 3,

internal/encoders/data_tracker_speed_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerSpeedChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerXYZChunkData
+		data        chunks.DataTrackerXYZChunkData
 	}{
 		{
 			description: "basic speed",
 			expected: []byte{
 				1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 			},
-			data: decoders.DataTrackerXYZChunkData{
+			data: chunks.DataTrackerXYZChunkData{
 				X: 1,
 				Y: 2,
 				Z: 3,

internal/encoders/data_tracker_status_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerStatusChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerStatusChunkData
+		data        chunks.DataTrackerStatusChunkData
 	}{
 		{
 			description: "basic status",
 			expected: []byte{
 				3, 0, 4, 0, 0, 0, 128, 63,
 			},
-			data: decoders.DataTrackerStatusChunkData{
+			data: chunks.DataTrackerStatusChunkData{
 				Validity: 1,
 			},
 		},

internal/encoders/data_tracker_timestamp_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerTimestampChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerTimestampChunkData
+		data        chunks.DataTrackerTimestampChunkData
 	}{
 		{
 			description: "basic timestamp",
 			expected: []byte{
 				6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
 			},
-			data: decoders.DataTrackerTimestampChunkData{
+			data: chunks.DataTrackerTimestampChunkData{
 				Timestamp: 1234567890,
 			},
 		},

internal/encoders/data_tracker_trgtpos_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestDataTrackerTrgtPosChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.DataTrackerXYZChunkData
+		data        chunks.DataTrackerXYZChunkData
 	}{
 		{
 			description: "basic target position",
 			expected: []byte{
 				5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
 			},
-			data: decoders.DataTrackerXYZChunkData{
+			data: chunks.DataTrackerXYZChunkData{
 				X: 1,
 				Y: 2,
 				Z: 3,

internal/encoders/info_system_name_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestInfoSystemNameChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.InfoSystemNameChunkData
+		data        chunks.InfoSystemNameChunkData
 	}{
 		{
 			description: "InfoSystemNameChunk",
 			expected: []byte{
 				1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114,
 			},
-			data: decoders.InfoSystemNameChunkData{
+			data: chunks.InfoSystemNameChunkData{
 				SystemName: "PSN Server",
 			},
 		},

internal/encoders/info_tracker_chunk_test.go

@@ -5,32 +5,32 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestInfoTrackerChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		chunk       decoders.InfoTrackerChunk
+		chunk       chunks.InfoTrackerChunk
 	}{
 		{
 			description: "InfoTrackerChunk",
 			expected: []byte{
 				1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			chunk: decoders.InfoTrackerChunk{
+			chunk: chunks.InfoTrackerChunk{
-				Chunk: decoders.Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-					Header:    decoders.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
+					Header:    chunks.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
 				},
-				Data: decoders.InfoTrackerChunkData{
+				Data: chunks.InfoTrackerChunkData{
-					TrackerName: &decoders.InfoTrackerNameChunk{
+					TrackerName: &chunks.InfoTrackerNameChunk{
-						Chunk: decoders.Chunk{
+						Chunk: chunks.Chunk{
 							ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-							Header:    decoders.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+							Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 						},
-						Data: decoders.InfoTrackerNameChunkData{
+						Data: chunks.InfoTrackerNameChunkData{
 							TrackerName: "Tracker 1",
 						},
 					},

internal/encoders/info_tracker_list_chunk_test.go

@@ -5,39 +5,39 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestInfoTrackerListChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		chunk       decoders.InfoTrackerListChunk
+		chunk       chunks.InfoTrackerListChunk
 	}{
 		{
 			description: "InfoTrackerListChunk",
 			expected: []byte{
 				2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			chunk: decoders.InfoTrackerListChunk{
+			chunk: chunks.InfoTrackerListChunk{
-				Chunk: decoders.Chunk{
+				Chunk: chunks.Chunk{
 					ChunkData: []byte{1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-					Header:    decoders.ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
+					Header:    chunks.ChunkHeader{DataLen: 17, Id: 2, HasSubchunks: true},
 				},
-				Data: decoders.InfoTrackerListChunkData{
+				Data: chunks.InfoTrackerListChunkData{
-					Trackers: []decoders.InfoTrackerChunk{
+					Trackers: []chunks.InfoTrackerChunk{
 						{
-							Chunk: decoders.Chunk{
+							Chunk: chunks.Chunk{
 								ChunkData: []byte{0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49},
-								Header:    decoders.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
+								Header:    chunks.ChunkHeader{DataLen: 13, Id: 1, HasSubchunks: true},
 							},
-							Data: decoders.InfoTrackerChunkData{
+							Data: chunks.InfoTrackerChunkData{
-								TrackerName: &decoders.InfoTrackerNameChunk{
+								TrackerName: &chunks.InfoTrackerNameChunk{
-									Chunk: decoders.Chunk{
+									Chunk: chunks.Chunk{
 										ChunkData: []byte{84, 114, 97, 99, 107, 101, 114, 32, 49},
-										Header:    decoders.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
+										Header:    chunks.ChunkHeader{DataLen: 9, Id: 0, HasSubchunks: false},
 									},
-									Data: decoders.InfoTrackerNameChunkData{
+									Data: chunks.InfoTrackerNameChunkData{
 										TrackerName: "Tracker 1",
 									},
 								},

internal/encoders/info_tracker_name_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestInfoTrackerNameChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.InfoTrackerNameChunkData
+		data        chunks.InfoTrackerNameChunkData
 	}{
 		{
 			description: "InfoTrackerNameChunk",
 			expected: []byte{
 				0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
 			},
-			data: decoders.InfoTrackerNameChunkData{
+			data: chunks.InfoTrackerNameChunkData{
 				TrackerName: "Tracker 1",
 			},
 		},

internal/encoders/packet_header_chunk_test.go

@@ -5,21 +5,21 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 )
 
 func TestPacketHeaderChunkEncoding(t *testing.T) {
 	testCases := []struct {
 		description string
 		expected    []byte
-		data        decoders.PacketHeaderChunkData
+		data        chunks.PacketHeaderChunkData
 	}{
 		{
 			description: "PacketHeaderChunk",
 			expected: []byte{
 				0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123,
 			},
-			data: decoders.PacketHeaderChunkData{
+			data: chunks.PacketHeaderChunkData{
 				PacketTimestamp:  1234567890,
 				VersionHigh:      2,
 				VersionLow:       3,

tracker.go

@@ -1,7 +1,7 @@
 package psn
 
 import (
-	"github.com/jwetzell/psn-go/internal/decoders"
+	"github.com/jwetzell/psn-go/internal/chunks"
 	"github.com/jwetzell/psn-go/internal/encoders"
 )
 
@@ -138,12 +138,12 @@ func (t *Tracker) GetInfoChunk() []byte {
 	return encoders.EncodeInfoTrackerChunk(t.Id, encoders.EncodeInfoTrackerNameChunk(t.Name))
 }
 
-func (t *Tracker) UpdateInfo(infoTrackerChunk decoders.InfoTrackerChunk) {
+func (t *Tracker) UpdateInfo(infoTrackerChunk chunks.InfoTrackerChunk) {
 	t.Id = infoTrackerChunk.Chunk.Header.Id
 	t.Name = infoTrackerChunk.Data.TrackerName.Data.TrackerName
 }
 
-func (t *Tracker) UpdateData(dataTrackerChunk decoders.DataTrackerChunk) {
+func (t *Tracker) UpdateData(dataTrackerChunk chunks.DataTrackerChunk) {
 	if dataTrackerChunk.Data.Pos != nil {
 		t.SetPos(dataTrackerChunk.Data.Pos.Data.X, dataTrackerChunk.Data.Pos.Data.Y, dataTrackerChunk.Data.Pos.Data.Z)
 	}
@@ -173,13 +173,13 @@ func (t *Tracker) UpdateData(dataTrackerChunk decoders.DataTrackerChunk) {
 	}
 }
 
-func TrackerFromInfo(infoTrackerChunk decoders.InfoTrackerChunk) *Tracker {
+func TrackerFromInfo(infoTrackerChunk chunks.InfoTrackerChunk) *Tracker {
 	var tracker Tracker
 	tracker.UpdateInfo(infoTrackerChunk)
 	return &tracker
 }
 
-func TrackerFromData(dataTrackerChunk decoders.DataTrackerChunk) *Tracker {
+func TrackerFromData(dataTrackerChunk chunks.DataTrackerChunk) *Tracker {
 	var tracker Tracker
 	tracker.UpdateData(dataTrackerChunk)
 	return &tracker