add client TLS publish tests

client.go

@@ -1811,7 +1811,7 @@ func (c *Client) runWriter() {
 			}
 		}
 
-	default: //TCP
+	default: // TCP
 		writeFunc = func(trackID int, isRTP bool, payload []byte) {
 			if isRTP {
 				if c.tracks[trackID].rtcpSender != nil {

client_publish_test.go

@@ -2,6 +2,7 @@ package gortsplib
 
 import (
 	"bufio"
+	"crypto/tls"
 	"net"
 	"strings"
 	"testing"
@@ -20,12 +21,25 @@ func TestClientPublishSerial(t *testing.T) {
 	for _, transport := range []string{
 		"udp",
 		"tcp",
+		"tls",
 	} {
 		t.Run(transport, func(t *testing.T) {
 			l, err := net.Listen("tcp", "localhost:8554")
 			require.NoError(t, err)
 			defer l.Close()
 
+			var scheme string
+			if transport == "tls" {
+				scheme = "rtsps"
+
+				cert, err := tls.X509KeyPair(serverCert, serverKey)
+				require.NoError(t, err)
+
+				l = tls.NewListener(l, &tls.Config{Certificates: []tls.Certificate{cert}})
+			} else {
+				scheme = "rtsp"
+			}
+
 			serverDone := make(chan struct{})
 			defer func() { <-serverDone }()
 			go func() {
@@ -39,7 +53,7 @@ func TestClientPublishSerial(t *testing.T) {
 				req, err := readRequest(bconn.Reader)
 				require.NoError(t, err)
 				require.Equal(t, base.Options, req.Method)
-				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL(scheme+"://localhost:8554/teststream"), req.URL)
 
 				err = base.Response{
 					StatusCode: base.StatusOK,
@@ -56,7 +70,7 @@ func TestClientPublishSerial(t *testing.T) {
 				req, err = readRequest(bconn.Reader)
 				require.NoError(t, err)
 				require.Equal(t, base.Announce, req.Method)
-				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL(scheme+"://localhost:8554/teststream"), req.URL)
 
 				err = base.Response{
 					StatusCode: base.StatusOK,
@@ -66,7 +80,7 @@ func TestClientPublishSerial(t *testing.T) {
 				req, err = readRequest(bconn.Reader)
 				require.NoError(t, err)
 				require.Equal(t, base.Setup, req.Method)
-				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream/trackID=0"), req.URL)
+				require.Equal(t, mustParseURL(scheme+"://localhost:8554/teststream/trackID=0"), req.URL)
 
 				var inTH headers.Transport
 				err = inTH.Read(req.Header["Transport"])
@@ -111,7 +125,7 @@ func TestClientPublishSerial(t *testing.T) {
 				req, err = readRequest(bconn.Reader)
 				require.NoError(t, err)
 				require.Equal(t, base.Record, req.Method)
-				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL(scheme+"://localhost:8554/teststream"), req.URL)
 
 				err = base.Response{
 					StatusCode: base.StatusOK,
@@ -150,7 +164,7 @@ func TestClientPublishSerial(t *testing.T) {
 				req, err = readRequest(bconn.Reader)
 				require.NoError(t, err)
 				require.Equal(t, base.Teardown, req.Method)
-				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL(scheme+"://localhost:8554/teststream"), req.URL)
 
 				err = base.Response{
 					StatusCode: base.StatusOK,
@@ -161,6 +175,9 @@ func TestClientPublishSerial(t *testing.T) {
 			recvDone := make(chan struct{})
 
 			c := &Client{
+				TLSConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
 				Transport: func() *Transport {
 					if transport == "udp" {
 						v := TransportUDP
@@ -176,10 +193,12 @@ func TestClientPublishSerial(t *testing.T) {
 				},
 			}
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
-			err = c.StartPublishing("rtsp://localhost:8554/teststream",
+			err = c.StartPublishing(scheme+"://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
 
@@ -208,12 +227,25 @@ func TestClientPublishParallel(t *testing.T) {
 	for _, transport := range []string{
 		"udp",
 		"tcp",
+		"tls",
 	} {
 		t.Run(transport, func(t *testing.T) {
 			l, err := net.Listen("tcp", "localhost:8554")
 			require.NoError(t, err)
 			defer l.Close()
 
+			var scheme string
+			if transport == "tls" {
+				scheme = "rtsps"
+
+				cert, err := tls.X509KeyPair(serverCert, serverKey)
+				require.NoError(t, err)
+
+				l = tls.NewListener(l, &tls.Config{Certificates: []tls.Certificate{cert}})
+			} else {
+				scheme = "rtsp"
+			}
+
 			serverDone := make(chan struct{})
 			defer func() { <-serverDone }()
 			go func() {
@@ -301,6 +333,9 @@ func TestClientPublishParallel(t *testing.T) {
 			}()
 
 			c := &Client{
+				TLSConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
 				Transport: func() *Transport {
 					if transport == "udp" {
 						v := TransportUDP
@@ -311,13 +346,15 @@ func TestClientPublishParallel(t *testing.T) {
 				}(),
 			}
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			writerDone := make(chan struct{})
 			defer func() { <-writerDone }()
 
-			err = c.StartPublishing("rtsp://localhost:8554/teststream",
+			err = c.StartPublishing(scheme+"://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
 			defer c.Close()
@@ -468,7 +505,9 @@ func TestClientPublishPauseSerial(t *testing.T) {
 				}(),
 			}
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -601,7 +640,9 @@ func TestClientPublishPauseParallel(t *testing.T) {
 				}(),
 			}
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -739,7 +780,9 @@ func TestClientPublishAutomaticProtocol(t *testing.T) {
 		require.NoError(t, err)
 	}()
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	c := Client{}
@@ -875,7 +918,9 @@ func TestClientPublishRTCPReport(t *testing.T) {
 		udpSenderReportPeriod: 1 * time.Second,
 	}
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	err = c.StartPublishing("rtsp://localhost:8554/teststream",
@@ -1010,7 +1055,9 @@ func TestClientPublishIgnoreTCPRTPPackets(t *testing.T) {
 		},
 	}
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	err = c.StartPublishing("rtsp://localhost:8554/teststream",

client_read_test.go

@@ -24,7 +24,9 @@ import (
 )
 
 func TestClientReadTracks(t *testing.T) {
-	track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track1, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	track2, err := NewTrackAAC(96, &TrackConfigAAC{Type: 2, SampleRate: 44100, ChannelCount: 2})
@@ -223,7 +225,9 @@ func TestClientRead(t *testing.T) {
 				require.Equal(t, base.Describe, req.Method)
 				require.Equal(t, mustParseURL(scheme+"://"+listenIP+":8554/test/stream?param=value"), req.URL)
 
-				track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+				track, err := NewTrackH264(96, &TrackConfigH264{
+					[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+				})
 				require.NoError(t, err)
 
 				track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
@@ -479,7 +483,9 @@ func TestClientReadNonStandardFrameSize(t *testing.T) {
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
@@ -580,10 +586,14 @@ func TestClientReadPartial(t *testing.T) {
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://"+listenIP+":8554/teststream"), req.URL)
 
-		track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track1, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
-		track2, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track2, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track1, track2})
@@ -721,7 +731,9 @@ func TestClientReadNoContentBase(t *testing.T) {
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -834,7 +846,9 @@ func TestClientReadAnyPort(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, base.Describe, req.Method)
 
-				track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+				track, err := NewTrackH264(96, &TrackConfigH264{
+					[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+				})
 				require.NoError(t, err)
 
 				tracks := cloneAndClearTracks(Tracks{track})
@@ -985,7 +999,9 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
 			require.NoError(t, err)
 			require.Equal(t, base.Describe, req.Method)
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			tracks := cloneAndClearTracks(Tracks{track})
@@ -1115,7 +1131,9 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
 			err = v.ValidateRequest(req)
 			require.NoError(t, err)
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			tracks := cloneAndClearTracks(Tracks{track})
@@ -1303,7 +1321,9 @@ func TestClientReadDifferentInterleavedIDs(t *testing.T) {
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track1, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track1})
@@ -1460,7 +1480,9 @@ func TestClientReadRedirect(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, base.Describe, req.Method)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -1617,7 +1639,9 @@ func TestClientReadPause(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, base.Describe, req.Method)
 
-				track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+				track, err := NewTrackH264(96, &TrackConfigH264{
+					[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+				})
 				require.NoError(t, err)
 
 				tracks := cloneAndClearTracks(Tracks{track})
@@ -1787,7 +1811,9 @@ func TestClientReadRTCPReport(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, base.Describe, req.Method)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -1957,7 +1983,9 @@ func TestClientReadErrorTimeout(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, base.Describe, req.Method)
 
-				track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+				track, err := NewTrackH264(96, &TrackConfigH264{
+					[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+				})
 				require.NoError(t, err)
 
 				tracks := cloneAndClearTracks(Tracks{track})
@@ -2105,7 +2133,9 @@ func TestClientReadIgnoreTCPInvalidTrack(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, base.Describe, req.Method)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -2230,7 +2260,9 @@ func TestClientReadSeek(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, base.Describe, req.Method)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})

client_test.go

@@ -117,7 +117,9 @@ func TestClientSession(t *testing.T) {
 
 		require.Equal(t, base.HeaderValue{"123456"}, req.Header["Session"])
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -199,7 +201,9 @@ func TestClientAuth(t *testing.T) {
 		err = v.ValidateRequest(req)
 		require.NoError(t, err)
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := cloneAndClearTracks(Tracks{track})
@@ -264,7 +268,9 @@ func TestClientDescribeCharset(t *testing.T) {
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track1, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		err = base.Response{

server_publish_test.go

@@ -27,7 +27,9 @@ func invalidURLAnnounceReq(t *testing.T, control string) base.Request {
 			"Content-Type": base.HeaderValue{"application/sdp"},
 		},
 		Body: func() []byte {
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 			track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
 				Key:   "control",
@@ -258,7 +260,9 @@ func TestServerPublishSetupPath(t *testing.T) {
 			defer conn.Close()
 			bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 			track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
 				Key:   "control",
@@ -354,7 +358,9 @@ func TestServerPublishErrorSetupDifferentPaths(t *testing.T) {
 	defer conn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	tracks := Tracks{track}
@@ -437,7 +443,9 @@ func TestServerPublishErrorSetupTrackTwice(t *testing.T) {
 	defer conn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	tracks := Tracks{track}
@@ -537,10 +545,14 @@ func TestServerPublishErrorRecordPartialTracks(t *testing.T) {
 	defer conn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-	track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track1, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
-	track2, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track2, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	tracks := Tracks{track1, track2}
@@ -686,7 +698,9 @@ func TestServerPublish(t *testing.T) {
 
 			<-connOpened
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			tracks := Tracks{track}
@@ -876,7 +890,9 @@ func TestServerPublishNonStandardFrameSize(t *testing.T) {
 	defer nconn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(nconn), bufio.NewWriter(nconn))
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
@@ -977,7 +993,9 @@ func TestServerPublishErrorInvalidProtocol(t *testing.T) {
 	defer conn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	tracks := Tracks{track}
@@ -1081,7 +1099,9 @@ func TestServerPublishRTCPReport(t *testing.T) {
 	defer conn.Close()
 	bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	tracks := Tracks{track}
@@ -1257,7 +1277,9 @@ func TestServerPublishTimeout(t *testing.T) {
 			defer nconn.Close()
 			bconn := bufio.NewReadWriter(bufio.NewReader(nconn), bufio.NewWriter(nconn))
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			tracks := Tracks{track}
@@ -1385,7 +1407,9 @@ func TestServerPublishWithoutTeardown(t *testing.T) {
 			require.NoError(t, err)
 			bconn := bufio.NewReadWriter(bufio.NewReader(nconn), bufio.NewWriter(nconn))
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			tracks := Tracks{track}
@@ -1505,7 +1529,9 @@ func TestServerPublishUDPChangeConn(t *testing.T) {
 		defer conn.Close()
 		bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
 
-		track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+		track, err := NewTrackH264(96, &TrackConfigH264{
+			[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+		})
 		require.NoError(t, err)
 
 		tracks := Tracks{track}

server_read_test.go

@@ -91,7 +91,9 @@ func TestServerReadSetupPath(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track, track, track, track, track})
@@ -150,7 +152,9 @@ func TestServerReadSetupErrors(t *testing.T) {
 		t.Run(ca, func(t *testing.T) {
 			connClosed := make(chan struct{})
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track})
@@ -267,7 +271,9 @@ func TestServerRead(t *testing.T) {
 			sessionClosed := make(chan struct{})
 			framesReceived := make(chan struct{})
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track})
@@ -569,7 +575,9 @@ func TestServerRead(t *testing.T) {
 }
 
 func TestServerReadVLCMulticast(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -617,7 +625,9 @@ func TestServerReadVLCMulticast(t *testing.T) {
 }
 
 func TestServerReadNonStandardFrameSize(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -700,7 +710,9 @@ func TestServerReadTCPResponseBeforeFrames(t *testing.T) {
 	writerDone := make(chan struct{})
 	writerTerminate := make(chan struct{})
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -794,7 +806,9 @@ func TestServerReadTCPResponseBeforeFrames(t *testing.T) {
 }
 
 func TestServerReadPlayPlay(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -876,7 +890,9 @@ func TestServerReadPlayPausePlay(t *testing.T) {
 	writerDone := make(chan struct{})
 	writerTerminate := make(chan struct{})
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -994,7 +1010,9 @@ func TestServerReadPlayPausePause(t *testing.T) {
 	writerDone := make(chan struct{})
 	writerTerminate := make(chan struct{})
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -1119,7 +1137,9 @@ func TestServerReadTimeout(t *testing.T) {
 		t.Run(transport, func(t *testing.T) {
 			sessionClosed := make(chan struct{})
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track})
@@ -1211,7 +1231,9 @@ func TestServerReadWithoutTeardown(t *testing.T) {
 			connClosed := make(chan struct{})
 			sessionClosed := make(chan struct{})
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track})
@@ -1309,7 +1331,9 @@ func TestServerReadWithoutTeardown(t *testing.T) {
 }
 
 func TestServerReadUDPChangeConn(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -1406,10 +1430,14 @@ func TestServerReadUDPChangeConn(t *testing.T) {
 }
 
 func TestServerReadPartialTracks(t *testing.T) {
-	track1, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track1, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
-	track2, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track2, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track1, track2})
@@ -1574,7 +1602,9 @@ func TestServerReadAdditionalInfos(t *testing.T) {
 		return &ri, ssrcs
 	}
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track, track})
@@ -1694,7 +1724,9 @@ func TestServerReadAdditionalInfos(t *testing.T) {
 }
 
 func TestServerReadErrorUDPSamePorts(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})

server_test.go

@@ -685,7 +685,9 @@ func TestServerErrorInvalidMethod(t *testing.T) {
 }
 
 func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -783,7 +785,9 @@ func TestServerErrorTCPTwoConnOneSession(t *testing.T) {
 }
 
 func TestServerErrorTCPOneConnTwoSessions(t *testing.T) {
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -1046,7 +1050,9 @@ func TestServerSessionClose(t *testing.T) {
 func TestServerSessionAutoClose(t *testing.T) {
 	sessionClosed := make(chan struct{})
 
-	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+	track, err := NewTrackH264(96, &TrackConfigH264{
+		[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+	})
 	require.NoError(t, err)
 
 	stream := NewServerStream(Tracks{track})
@@ -1113,7 +1119,9 @@ func TestServerErrorInvalidPath(t *testing.T) {
 		t.Run(string(method), func(t *testing.T) {
 			connClosed := make(chan struct{})
 
-			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+			track, err := NewTrackH264(96, &TrackConfigH264{
+				[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+			})
 			require.NoError(t, err)
 
 			stream := NewServerStream(Tracks{track})
@@ -1155,7 +1163,9 @@ func TestServerErrorInvalidPath(t *testing.T) {
 			sxID := ""
 
 			if method == base.Record {
-				track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
+				track, err := NewTrackH264(96, &TrackConfigH264{
+					[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04},
+				})
 				require.NoError(t, err)
 
 				tracks := Tracks{track}