rtcrec: basic serialization and deserialization

go.mod

···
 	github.com/decred/dcrd/dcrec/secp256k1 v1.0.4
 	github.com/dunglas/httpsfv v1.0.2
 	github.com/ethereum/go-ethereum v1.14.7
+	github.com/fxamacker/cbor/v2 v2.8.0
 	github.com/go-git/go-git/v5 v5.12.0
 	github.com/go-gst/go-glib v1.4.0
 	github.com/go-gst/go-gst v1.4.0
···
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/vektah/gqlparser/v2 v2.5.22 // indirect
 	github.com/wlynxg/anet v0.0.5 // indirect
+	github.com/x448/float16 v0.8.4 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/xen0n/gosmopolitan v1.3.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect

go.sum

···
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+github.com/fxamacker/cbor/v2 v2.8.0 h1:fFtUGXUzXPHTIUdne5+zzMPTfffl3RD5qYnkY40vtxU=
+github.com/fxamacker/cbor/v2 v2.8.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
 github.com/fzipp/gocyclo v0.6.0 h1:lsblElZG7d3ALtGMx9fmxeTKZaLLpU8mET09yN4BBLo=
 github.com/fzipp/gocyclo v0.6.0/go.mod h1:rXPyn8fnlpa0R2csP/31uerbiVBugk5whMdlyaLkLoA=
 github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=
···
 github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=
 github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
 github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
 github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
 github.com/xen0n/gosmopolitan v1.3.0 h1:zAZI1zefvo7gcpbCOrPSHJZJYA9ZgLfJqtKzZ5pHqQM=

pkg/rtcrec/peerproxy.go

···
 type RTPReceiver interface {
 }
 
-func TranscieverPlease() RTPTransceiver {
-	return &webrtc.RTPTransceiver{}
-}
-
-func TranscieverThankYou() *webrtc.RTPTransceiver {
-	t, ok := TranscieverPlease().(*webrtc.RTPTransceiver)
-	if !ok {
-		panic("TranscieverPlease() is not a webrtc.RTPTransceiver")
+func GatheringCompletePromise(pc PeerConnection) <-chan struct{} {
+	wrapped, ok := pc.(*WrappedPeerConnection)
+	if ok {
+		return webrtc.GatheringCompletePromise(wrapped.pionpc)
 	}
-	return t
+	recorder, ok := pc.(*RecorderPeerConnection)
+	if ok {
+		return webrtc.GatheringCompletePromise(recorder.pionpc)
+	}
+	panic("unknown peer connection type")
 }

pkg/rtcrec/recorder.go

···
+package rtcrec
+
+import (
+	"github.com/pion/rtcp"
+	"github.com/pion/webrtc/v4"
+)
+
+type RecorderPeerConnection struct {
+	pionpc *webrtc.PeerConnection
+}
+
+func NewRecorderPeerConnection(pionpc *webrtc.PeerConnection) PeerConnection {
+	return &RecorderPeerConnection{
+		pionpc: pionpc,
+	}
+}
+
+func (pc *RecorderPeerConnection) Close() error {
+	return pc.pionpc.Close()
+}
+
+func (pc *RecorderPeerConnection) CreateAnswer(options *webrtc.AnswerOptions) (webrtc.SessionDescription, error) {
+	return pc.pionpc.CreateAnswer(options)
+}
+
+func (pc *RecorderPeerConnection) CreateOffer(options *webrtc.OfferOptions) (webrtc.SessionDescription, error) {
+	return pc.pionpc.CreateOffer(options)
+}
+
+func (pc *RecorderPeerConnection) SetLocalDescription(desc webrtc.SessionDescription) error {
+	return pc.pionpc.SetLocalDescription(desc)
+}
+
+func (pc *RecorderPeerConnection) SetRemoteDescription(desc webrtc.SessionDescription) error {
+	return pc.pionpc.SetRemoteDescription(desc)
+}
+
+func (pc *RecorderPeerConnection) LocalDescription() *webrtc.SessionDescription {
+	return pc.pionpc.LocalDescription()
+}
+
+func (pc *RecorderPeerConnection) RemoteDescription() *webrtc.SessionDescription {
+	return pc.pionpc.RemoteDescription()
+}
+
+func (pc *RecorderPeerConnection) OnICEConnectionStateChange(f func(webrtc.ICEConnectionState)) {
+	pc.pionpc.OnICEConnectionStateChange(f)
+}
+
+func (pc *RecorderPeerConnection) OnConnectionStateChange(f func(webrtc.PeerConnectionState)) {
+	pc.pionpc.OnConnectionStateChange(f)
+}
+
+func (pc *RecorderPeerConnection) OnTrack(f func(TrackRemote, RTPReceiver)) {
+	pc.pionpc.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
+		f(track, receiver)
+	})
+}
+
+func (pc *RecorderPeerConnection) WriteRTCP(pkts []rtcp.Packet) error {
+	return pc.pionpc.WriteRTCP(pkts)
+}
+
+func (pc *RecorderPeerConnection) AddTransceiverFromKind(kind webrtc.RTPCodecType, init ...webrtc.RTPTransceiverInit) (RTPTransceiver, error) {
+	return pc.pionpc.AddTransceiverFromKind(kind, init...)
+}
+
+func (pc *RecorderPeerConnection) ICEGatheringState() webrtc.ICEGatheringState {
+	return pc.pionpc.ICEGatheringState()
+}
+
+func (pc *RecorderPeerConnection) OnDataChannel(f func(*webrtc.DataChannel)) {
+	pc.pionpc.OnDataChannel(f)
+}
+
+func (pc *RecorderPeerConnection) OnNegotiationNeeded(f func()) {
+	pc.pionpc.OnNegotiationNeeded(f)
+}

pkg/rtcrec/recording.go

···
-package rtcrec

pkg/rtcrec/webrtc_recording.go

···
+package rtcrec
+
+import (
+	"io"
+	"time"
+
+	"github.com/fxamacker/cbor/v2"
+)
+
+type WebRTCRecording struct {
+	Events []WebRTCEvent
+}
+
+type WebRTCEvent struct {
+	Offer  *OfferEvent
+	Answer *AnswerEvent
+	Time   time.Time
+}
+
+type OfferEvent struct {
+	Offer string
+}
+
+type AnswerEvent struct {
+	Answer string
+}
+
+type RecorderStream struct {
+	encoder *cbor.Encoder
+}
+
+func NewRecorderStream(w io.Writer) (*RecorderStream, error) {
+	encoder := cbor.NewEncoder(w)
+
+	err := encoder.StartIndefiniteArray()
+	if err != nil {
+		return nil, err
+	}
+
+	return &RecorderStream{
+		encoder: encoder,
+	}, nil
+}
+
+func (s *RecorderStream) Event(event WebRTCEvent) error {
+	event.Time = time.Now()
+	return s.encoder.Encode(event)
+}
+
+func (s *RecorderStream) Close() error {
+	return s.encoder.EndIndefinite()
+}

pkg/rtcrec/webrtc_recording_test.go

···
+package rtcrec
+
+import (
+	"os"
+	"testing"
+
+	"github.com/fxamacker/cbor/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWebRTCRecording(t *testing.T) {
+	// Create a temporary file for testing
+	tmpfile, err := os.CreateTemp("", "webrtc-recording-test-*")
+	require.NoError(t, err)
+
+	// Create recorder stream writing to temp file
+	recorder, err := NewRecorderStream(tmpfile)
+	require.NoError(t, err)
+
+	// Test recording an offer event
+	offerEvent := WebRTCEvent{
+		Offer: &OfferEvent{
+			Offer: "test-offer",
+		},
+	}
+	require.NoError(t, recorder.Event(offerEvent))
+
+	// Test recording an answer event
+	answerEvent := WebRTCEvent{
+		Answer: &AnswerEvent{
+			Answer: "test-answer",
+		},
+	}
+	require.NoError(t, recorder.Event(answerEvent))
+
+	err = recorder.Close()
+	require.NoError(t, err)
+	err = tmpfile.Close()
+	require.NoError(t, err)
+
+	// Read the file and verify the contents
+	contents, err := os.ReadFile(tmpfile.Name())
+	require.NoError(t, err)
+
+	var evs []WebRTCEvent
+	err = cbor.Unmarshal(contents, &evs)
+	require.NoError(t, err)
+
+	require.Equal(t, 2, len(evs))
+	require.Equal(t, offerEvent.Offer, evs[0].Offer)
+	require.Equal(t, answerEvent.Answer, evs[1].Answer)
+}

pkg/rtcrec/wrapped.go

···
 	}
 }
 
-func GatheringCompletePromise(pc PeerConnection) <-chan struct{} {
-	wrapped, ok := pc.(*WrappedPeerConnection)
-	if !ok {
-		panic("pc is not a *WrappedPeerConnection")
-	}
-	return webrtc.GatheringCompletePromise(wrapped.pionpc)
-}
-
 func (pc *WrappedPeerConnection) Close() error {
 	return pc.pionpc.Close()
 }