feat: support file based replay telemetry

Author: vwhitteron

Makefile

@@ -121,6 +121,12 @@ run: build
 run/live:
 	@go run ${MAIN_PACKAGE_PATH}/main.go
 
+## run/capture_replay: capture a replay and save to gt7-replay.gtz
+.PHONY: run/capture-replay
+run/capture-replay:
+	@go run cmd/capture_replay/main.go
+	@echo "Replay saved to gt7-replay.gtz"
+
 ## clean: clean up project and return to a pristine state
 .PHONY: clean
 clean:

README.md

@@ -45,9 +45,9 @@ import telemetry_client "github.com/vwhitteron/gt-telemetry"
 Construct a new GT client and start reading the telemetry stream. All configuration fields are optional with the default values show in the example.
 
 ```go
-config := telemetry_client.Config{
-    IPAddr: "255.255.255.255",
-    LogLevel: "info",
+config := telemetry_client.GTClientOpts{
+    Source: "udp://255.255.255.255:33739"
+    LogLevel: "warn",
     StatsEnabled: false,
     VehicleDB: "./internal/vehicles/inventory.json",
 }
@@ -67,13 +67,43 @@ Read some data from the stream:
     )
 ```
 
+### Replay files ###
+
+Offline saves of replay files can also be used to read in telemetry data. Files can be in either plain (`*.gtr`) or compressed (`*.gtz`) format.
+
+Read telemetry from a replay file by setting the `Source` value in the `GTClientOpts` to a file URL, like so:
+
+```go
+config := telemetry_client.GTClientOpts{
+    Source: "file://examples/simple/replay.gtz"
+}
+```
+
+#### Saving a replay to a file ####
+
+Replays can be captured and saved to a file using `cmd/capture_replay/main.go`. Captures will be saved in plain or compressed formats according to the file extension as mentioned in the section above.
+
+A replay can be saved to a default file by running:
+
+```bash
+make run/capture-replay
+```
+
+Alternatively, the replay can be captured to a compressed file with a different name and location by running:
+
+```bash
+go run cmd/capture_replay/main.go -o /path/to/replay-file.gtz
+```
+
 ## Examples ##
 
-The [examples](./examples) directory contains an example for accessing most data made available by the library. The telemetry data can be viewed by running:
+The [examples](./examples) directory contains example code for accessing most data made available by the library. The telemetry data from a sample saved replay can be viewed by running:
 
 ```bash
 make run/live
 ```
 
+The example code can also read live telemetry data from a PlayStation by removing the `Source` field in the `GTClientOpts`.
+
 ## Acknowledgements ##
 Special thanks to [Nenkai](https://github.com/Nenkai) for the excellent work documenting the Gran Turismo telemetry protocol.

cmd/capture_replay/main.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"compress/gzip"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"time"
+
+	telemetry_client "github.com/vwhitteron/gt-telemetry"
+)
+
+func main() {
+	var outFile string
+
+	flag.StringVar(&outFile, "o", "gt7-replay.gtz", "Output file name. Default: gt7-replay.gtz")
+	flag.Parse()
+
+	fh, err := os.Create(outFile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fh.Close()
+
+	var buffer io.Writer
+	fileExt := outFile[len(outFile)-3:]
+	switch fileExt {
+	case "gtz":
+		buffer, err = gzip.NewWriterLevel(fh, gzip.BestCompression)
+		if err != nil {
+			log.Fatal(err.Error())
+		}
+		buffer.(*gzip.Writer).Comment = "Gran Turismo 7 Telemetry Replay"
+	case "gtr":
+		buffer = fh
+	default:
+		os.Remove(outFile)
+		log.Fatalf("Unsupported file extension %q, use either .gtr or .gtz", fileExt)
+	}
+
+	gt, err := telemetry_client.NewGTClient(telemetry_client.GTClientOpts{})
+	if err != nil {
+		fmt.Println("Error creating GT client: ", err)
+		os.Exit(1)
+	}
+
+	go gt.Run()
+
+	fmt.Println("Waiting for replay to start")
+
+	framesCaptured := -1
+	lastTimeOfDay := time.Duration(0)
+	sequenceID := ^uint32(0)
+	startTime := time.Duration(0)
+	diff := uint32(0)
+	for {
+		// ignore packets that have aldready been processed
+		if sequenceID == gt.Telemetry.SequenceID() {
+			timer := time.NewTimer(4 * time.Millisecond)
+			<-timer.C
+			continue
+		}
+
+		diff = gt.Telemetry.SequenceID() - sequenceID
+		sequenceID = gt.Telemetry.SequenceID()
+
+		// Set the last time seen when the first frame is received
+		if lastTimeOfDay == time.Duration(0) {
+			lastTimeOfDay = gt.Telemetry.TimeOfDay()
+			continue
+		}
+
+		// Finish recording when the replay restarts
+		if gt.Telemetry.TimeOfDay() <= startTime {
+			// The time of day sometimes flaps in the first few frames
+			if framesCaptured < 60 {
+				continue
+			}
+
+			fmt.Println("Replay restart detected")
+			if b, ok := buffer.(*gzip.Writer); ok {
+				if err := b.Flush(); err != nil {
+					log.Fatal(err)
+				}
+			}
+			break
+		}
+
+		// Start recording when the replay starts
+		if framesCaptured == -1 && gt.Telemetry.TimeOfDay() != lastTimeOfDay {
+			fmt.Printf("Starting capture, frame size: %d bytes\n", len(gt.DecipheredPacket))
+
+			startTime = gt.Telemetry.TimeOfDay()
+			framesCaptured = 0
+
+			extraData := fmt.Sprintf("Time of day: %+v, Manufacturer: %s, Model: %s",
+				startTime,
+				gt.Telemetry.VehicleManufacturer(),
+				gt.Telemetry.VehicleModel(),
+			)
+			if b, ok := buffer.(*gzip.Writer); ok {
+				b.Extra = []byte(extraData)
+			}
+
+			fmt.Println(extraData)
+		} else {
+			time.Sleep(4 * time.Millisecond)
+		}
+
+		// Write the frame to the gzip buffer
+		if framesCaptured >= 0 {
+			if diff > 1 {
+				fmt.Printf("Dropped %d frames\n", diff-1)
+			}
+
+			_, err := buffer.Write(gt.DecipheredPacket)
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			framesCaptured++
+			lastTimeOfDay = gt.Telemetry.TimeOfDay()
+		}
+
+		timer := time.NewTimer(4 * time.Millisecond)
+		<-timer.C
+
+		if framesCaptured%300 == 0 {
+			fmt.Printf("%d frames captured\n", framesCaptured)
+		}
+	}
+
+	fmt.Printf("Capture complete, total frames: %d\n", framesCaptured)
+}

examples/simple/main.go

@@ -10,6 +10,7 @@ import (
 
 func main() {
 	clientConfig := telemetry_client.GTClientOpts{
+		Source:       "file://examples/simple/replay.gtz",
 		StatsEnabled: true,
 	}
 
@@ -24,6 +25,10 @@ func main() {
 
 	sequenceID := uint32(0)
 	for {
+		if client.Finished {
+			break
+		}
+
 		if sequenceID == client.Telemetry.SequenceID() {
 			time.Sleep(8 * time.Millisecond)
 			continue
@@ -39,18 +44,12 @@ func main() {
 		hasTurbo := client.Telemetry.Flags().HasTurbo
 		boostStr := ""
 		if hasTurbo {
-			boostStr = fmt.Sprintf("Boost: %1.02f Bar", client.Telemetry.TurboBoostBar())
+			boostStr = fmt.Sprintf("Boost: %+1.02f Bar", client.Telemetry.TurboBoostBar())
 		}
 
 		fmt.Print("\033[H\033[2J")
-		fmt.Printf("Sequence ID:  %d  %s\nTime of day:  %+v\n",
+		fmt.Printf("Sequence ID:  %d\nTime of day:  %+v\n",
 			client.Telemetry.SequenceID(),
-			renderFlag(
-				client.Statistics.Heartbeat,
-				"Heartbeat",
-				"yellow",
-				"invisible",
-			),
 			client.Telemetry.TimeOfDay(),
 		)
 		fmt.Printf("Race          Lap: %d of %d  Last lap: %+v  Best lap: %+v  Start position: %d  Race entrants: %d\n",
@@ -95,7 +94,7 @@ func main() {
 			client.Telemetry.OilPressureKPA(),
 			boostStr,
 		)
-		fmt.Printf("Clutch        Position: %0.0f%%  Engagement: %0.0f%%  Output: %5.0f RPM\n",
+		fmt.Printf("Clutch        Position: %3.0f%%  Engagement: %3.0f%%  Output: %5.0f RPM\n",
 			client.Telemetry.ClutchActuationPercent(),
 			client.Telemetry.ClutchEngagementPercent(),
 			client.Telemetry.ClutchOutputRPM(),
@@ -226,7 +225,8 @@ func main() {
 			)
 		}
 
-		time.Sleep(64 * time.Millisecond)
+		timer := time.NewTimer(64 * time.Millisecond)
+		<-timer.C
 	}
 }