client: merge Client and ClientConn

client_publish_test.go

@@ -172,7 +172,7 @@ func TestClientPublishSerial(t *testing.T) {
 			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
 			require.NoError(t, err)
 
-			conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+			err = c.DialPublish("rtsp://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
 
@@ -180,7 +180,7 @@ func TestClientPublishSerial(t *testing.T) {
 			done := make(chan struct{})
 			go func() {
 				defer close(done)
-				conn.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
+				c.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
 					require.Equal(t, 0, trackID)
 					require.Equal(t, StreamTypeRTCP, streamType)
 					require.Equal(t, []byte{0x05, 0x06, 0x07, 0x08}, payload)
@@ -188,15 +188,15 @@ func TestClientPublishSerial(t *testing.T) {
 				})
 			}()
 
-			err = conn.WritePacketRTP(0,
+			err = c.WritePacketRTP(0,
 				[]byte{0x01, 0x02, 0x03, 0x04})
 			require.NoError(t, err)
 
 			<-recvDone
-			conn.Close()
+			c.Close()
 			<-done
 
-			err = conn.WritePacketRTP(0,
+			err = c.WritePacketRTP(0,
 				[]byte{0x01, 0x02, 0x03, 0x04})
 			require.Error(t, err)
 		})
@@ -316,10 +316,10 @@ func TestClientPublishParallel(t *testing.T) {
 			writerDone := make(chan struct{})
 			defer func() { <-writerDone }()
 
-			conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+			err = c.DialPublish("rtsp://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
-			defer conn.Close()
+			defer c.Close()
 
 			go func() {
 				defer close(writerDone)
@@ -328,7 +328,7 @@ func TestClientPublishParallel(t *testing.T) {
 				defer t.Stop()
 
 				for range t.C {
-					err := conn.WritePacketRTP(0,
+					err := c.WritePacketRTP(0,
 						[]byte{0x01, 0x02, 0x03, 0x04})
 					if err != nil {
 						return
@@ -470,26 +470,26 @@ func TestClientPublishPauseSerial(t *testing.T) {
 			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
 			require.NoError(t, err)
 
-			conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+			err = c.DialPublish("rtsp://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
-			defer conn.Close()
+			defer c.Close()
 
-			err = conn.WritePacketRTP(0,
+			err = c.WritePacketRTP(0,
 				[]byte{0x01, 0x02, 0x03, 0x04})
 			require.NoError(t, err)
 
-			_, err = conn.Pause()
+			_, err = c.Pause()
 			require.NoError(t, err)
 
-			err = conn.WritePacketRTP(0,
+			err = c.WritePacketRTP(0,
 				[]byte{0x01, 0x02, 0x03, 0x04})
 			require.Error(t, err)
 
-			_, err = conn.Record()
+			_, err = c.Record()
 			require.NoError(t, err)
 
-			err = conn.WritePacketRTP(0,
+			err = c.WritePacketRTP(0,
 				[]byte{0x01, 0x02, 0x03, 0x04})
 			require.NoError(t, err)
 		})
@@ -607,7 +607,7 @@ func TestClientPublishPauseParallel(t *testing.T) {
 			track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
 			require.NoError(t, err)
 
-			conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+			err = c.DialPublish("rtsp://localhost:8554/teststream",
 				Tracks{track})
 			require.NoError(t, err)
 
@@ -619,7 +619,7 @@ func TestClientPublishPauseParallel(t *testing.T) {
 				defer t.Stop()
 
 				for range t.C {
-					err := conn.WritePacketRTP(0,
+					err := c.WritePacketRTP(0,
 						[]byte{0x01, 0x02, 0x03, 0x04})
 					if err != nil {
 						return
@@ -629,11 +629,11 @@ func TestClientPublishPauseParallel(t *testing.T) {
 
 			time.Sleep(1 * time.Second)
 
-			_, err = conn.Pause()
+			_, err = c.Pause()
 			require.NoError(t, err)
 			<-writerDone
 
-			conn.Close()
+			c.Close()
 		})
 	}
 }
@@ -747,12 +747,12 @@ func TestClientPublishAutomaticProtocol(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+	err = c.DialPublish("rtsp://localhost:8554/teststream",
 		Tracks{track})
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	err = conn.WritePacketRTP(0,
+	err = c.WritePacketRTP(0,
 		[]byte{0x01, 0x02, 0x03, 0x04})
 	require.NoError(t, err)
 }
@@ -888,10 +888,10 @@ func TestClientPublishRTCPReport(t *testing.T) {
 	track, err := NewTrackH264(96, &TrackConfigH264{[]byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}})
 	require.NoError(t, err)
 
-	conn, err := c.DialPublish("rtsp://localhost:8554/teststream",
+	err = c.DialPublish("rtsp://localhost:8554/teststream",
 		Tracks{track})
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
 	byts, _ := (&rtp.Packet{
 		Header: rtp.Header{
@@ -904,11 +904,11 @@ func TestClientPublishRTCPReport(t *testing.T) {
 		},
 		Payload: []byte{0x01, 0x02, 0x03, 0x04},
 	}).Marshal()
-	err = conn.WritePacketRTP(0, byts)
+	err = c.WritePacketRTP(0, byts)
 	require.NoError(t, err)
 
 	time.Sleep(1300 * time.Millisecond)
 
-	err = conn.WritePacketRTP(0, byts)
+	err = c.WritePacketRTP(0, byts)
 	require.NoError(t, err)
 }

client_read_test.go

@@ -132,9 +132,9 @@ func TestClientReadTracks(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+	err = c.DialRead("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
 	track1.Media.Attributes = append(track1.Media.Attributes, psdp.Attribute{
 		Key:   "control",
@@ -161,7 +161,7 @@ func TestClientReadTracks(t *testing.T) {
 		{
 			Media: track3.Media,
 		},
-	}, conn.Tracks())
+	}, c.Tracks())
 }
 
 func TestClientRead(t *testing.T) {
@@ -412,14 +412,14 @@ func TestClientRead(t *testing.T) {
 				}(),
 			}
 
-			conn, err := c.DialRead(scheme + "://" + listenIP + ":8554/test/stream?param=value")
+			err = c.DialRead(scheme + "://" + listenIP + ":8554/test/stream?param=value")
 			require.NoError(t, err)
 
 			done := make(chan struct{})
 			counter := uint64(0)
 			go func() {
 				defer close(done)
-				conn.ReadFrames(func(id int, streamType StreamType, payload []byte) {
+				c.ReadFrames(func(id int, streamType StreamType, payload []byte) {
 					// skip multicast loopback
 					if transport == "multicast" {
 						add := atomic.AddUint64(&counter, 1)
@@ -432,16 +432,16 @@ func TestClientRead(t *testing.T) {
 					require.Equal(t, StreamTypeRTP, streamType)
 					require.Equal(t, []byte{0x01, 0x02, 0x03, 0x04}, payload)
 
-					err = conn.WritePacketRTCP(0, []byte{0x05, 0x06, 0x07, 0x08})
+					err = c.WritePacketRTCP(0, []byte{0x05, 0x06, 0x07, 0x08})
 					require.NoError(t, err)
 				})
 			}()
 
 			<-frameRecv
-			conn.Close()
+			c.Close()
 			<-done
 
-			conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+			c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 			})
 		})
 	}
@@ -568,7 +568,7 @@ func TestClientReadNonStandardFrameSize(t *testing.T) {
 	}()
 
 	<-frameRecv
-	conn.Close()
+	c.Close()
 	<-done
 }
 
@@ -675,24 +675,24 @@ func TestClientReadPartial(t *testing.T) {
 	u, err := base.ParseURL("rtsp://" + listenIP + ":8554/teststream")
 	require.NoError(t, err)
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	tracks, baseURL, _, err := conn.Describe(u)
+	tracks, baseURL, _, err := c.Describe(u)
 	require.NoError(t, err)
 
-	_, err = conn.Setup(headers.TransportModePlay, baseURL, tracks[1], 0, 0)
+	_, err = c.Setup(headers.TransportModePlay, baseURL, tracks[1], 0, 0)
 	require.NoError(t, err)
 
-	_, err = conn.Play(nil)
+	_, err = c.Play(nil)
 	require.NoError(t, err)
 
 	done := make(chan struct{})
 	frameRecv := make(chan struct{})
 	go func() {
 		defer close(done)
-		conn.ReadFrames(func(id int, streamType StreamType, payload []byte) {
+		c.ReadFrames(func(id int, streamType StreamType, payload []byte) {
 			require.Equal(t, 0, id)
 			require.Equal(t, StreamTypeRTP, streamType)
 			require.Equal(t, []byte{0x01, 0x02, 0x03, 0x04}, payload)
@@ -805,9 +805,9 @@ func TestClientReadNoContentBase(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+	err = c.DialRead("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
-	conn.Close()
+	c.Close()
 }
 
 func TestClientReadAnyPort(t *testing.T) {
@@ -924,20 +924,20 @@ func TestClientReadAnyPort(t *testing.T) {
 				AnyPortEnable: true,
 			}
 
-			conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+			err = c.DialRead("rtsp://localhost:8554/teststream")
 			require.NoError(t, err)
 
 			frameRecv := make(chan struct{})
 			done := make(chan struct{})
 			go func() {
 				defer close(done)
-				conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+				c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 					close(frameRecv)
 				})
 			}()
 
 			<-frameRecv
-			conn.Close()
+			c.Close()
 			<-done
 		})
 	}
@@ -1045,20 +1045,20 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
 
 		c := Client{}
 
-		conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+		err = c.DialRead("rtsp://localhost:8554/teststream")
 		require.NoError(t, err)
 
 		frameRecv := make(chan struct{})
 		done := make(chan struct{})
 		go func() {
 			defer close(done)
-			conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+			c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 				close(frameRecv)
 			})
 		}()
 
 		<-frameRecv
-		conn.Close()
+		c.Close()
 		<-done
 	})
 
@@ -1252,20 +1252,20 @@ func TestClientReadAutomaticProtocol(t *testing.T) {
 			ReadTimeout: 1 * time.Second,
 		}
 
-		conn, err := c.DialRead("rtsp://myuser:mypass@localhost:8554/teststream")
+		err = c.DialRead("rtsp://myuser:mypass@localhost:8554/teststream")
 		require.NoError(t, err)
 
 		frameRecv := make(chan struct{})
 		done := make(chan struct{})
 		go func() {
 			defer close(done)
-			conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+			c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 				close(frameRecv)
 			})
 		}()
 
 		<-frameRecv
-		conn.Close()
+		c.Close()
 		<-done
 	})
 }
@@ -1381,21 +1381,21 @@ func TestClientReadDifferentInterleavedIDs(t *testing.T) {
 		}(),
 	}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+	err = c.DialRead("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
 
 	frameRecv := make(chan struct{})
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+		c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 			require.Equal(t, 0, id)
 			close(frameRecv)
 		})
 	}()
 
 	<-frameRecv
-	conn.Close()
+	c.Close()
 	<-done
 }
 
@@ -1530,20 +1530,20 @@ func TestClientReadRedirect(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/path1")
+	err = c.DialRead("rtsp://localhost:8554/path1")
 	require.NoError(t, err)
 
 	frameRecv := make(chan struct{})
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+		c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 			close(frameRecv)
 		})
 	}()
 
 	<-frameRecv
-	conn.Close()
+	c.Close()
 	<-done
 }
 
@@ -1734,7 +1734,7 @@ func TestClientReadPause(t *testing.T) {
 				}(),
 			}
 
-			conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+			err = c.DialRead("rtsp://localhost:8554/teststream")
 			require.NoError(t, err)
 
 			firstFrame := int32(0)
@@ -1742,7 +1742,7 @@ func TestClientReadPause(t *testing.T) {
 			done := make(chan struct{})
 			go func() {
 				defer close(done)
-				conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+				c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 					if atomic.SwapInt32(&firstFrame, 1) == 0 {
 						close(frameRecv)
 					}
@@ -1750,14 +1750,14 @@ func TestClientReadPause(t *testing.T) {
 			}()
 
 			<-frameRecv
-			_, err = conn.Pause()
+			_, err = c.Pause()
 			require.NoError(t, err)
 			<-done
 
-			conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+			c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 			})
 
-			_, err = conn.Play(nil)
+			_, err = c.Play(nil)
 			require.NoError(t, err)
 
 			firstFrame = int32(0)
@@ -1765,7 +1765,7 @@ func TestClientReadPause(t *testing.T) {
 			done = make(chan struct{})
 			go func() {
 				defer close(done)
-				conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+				c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 					if atomic.SwapInt32(&firstFrame, 1) == 0 {
 						close(frameRecv)
 					}
@@ -1773,7 +1773,7 @@ func TestClientReadPause(t *testing.T) {
 			}()
 
 			<-frameRecv
-			conn.Close()
+			c.Close()
 			<-done
 		})
 	}
@@ -1925,7 +1925,7 @@ func TestClientReadRTCPReport(t *testing.T) {
 		receiverReportPeriod: 1 * time.Second,
 	}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+	err = c.DialRead("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
 
 	recv := 0
@@ -1933,7 +1933,7 @@ func TestClientReadRTCPReport(t *testing.T) {
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		conn.ReadFrames(func(id int, typ StreamType, payload []byte) {
+		c.ReadFrames(func(id int, typ StreamType, payload []byte) {
 			recv++
 			if recv >= 3 {
 				close(recvDone)
@@ -1944,7 +1944,7 @@ func TestClientReadRTCPReport(t *testing.T) {
 	time.Sleep(1300 * time.Millisecond)
 
 	<-recvDone
-	conn.Close()
+	c.Close()
 	<-done
 }
 
@@ -2092,11 +2092,11 @@ func TestClientReadErrorTimeout(t *testing.T) {
 				ReadTimeout:           1 * time.Second,
 			}
 
-			conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+			err = c.DialRead("rtsp://localhost:8554/teststream")
 			require.NoError(t, err)
-			defer conn.Close()
+			defer c.Close()
 
-			err = conn.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
+			err = c.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
 			})
 
 			switch transport {
@@ -2223,20 +2223,20 @@ func TestClientReadIgnoreTCPInvalidTrack(t *testing.T) {
 		}(),
 	}
 
-	conn, err := c.DialRead("rtsp://localhost:8554/teststream")
+	err = c.DialRead("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
 
 	recv := make(chan struct{})
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		conn.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
+		c.ReadFrames(func(trackID int, streamType StreamType, payload []byte) {
 			close(recv)
 		})
 	}()
 
 	<-recv
-	conn.Close()
+	c.Close()
 	<-done
 }
 
@@ -2379,29 +2379,29 @@ func TestClientReadSeek(t *testing.T) {
 	u, err := base.ParseURL("rtsp://localhost:8554/teststream")
 	require.NoError(t, err)
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	require.NoError(t, err)
 
-	tracks, baseURL, _, err := conn.Describe(u)
+	tracks, baseURL, _, err := c.Describe(u)
 	require.NoError(t, err)
 
 	for _, track := range tracks {
-		_, err := conn.Setup(headers.TransportModePlay, baseURL, track, 0, 0)
+		_, err := c.Setup(headers.TransportModePlay, baseURL, track, 0, 0)
 		require.NoError(t, err)
 	}
 
-	_, err = conn.Play(&headers.Range{
+	_, err = c.Play(&headers.Range{
 		Value: &headers.RangeNPT{
 			Start: headers.RangeNPTTime(5500 * time.Millisecond),
 		},
 	})
 	require.NoError(t, err)
 
-	_, err = conn.Seek(&headers.Range{
+	_, err = c.Seek(&headers.Range{
 		Value: &headers.RangeNPT{
 			Start: headers.RangeNPTTime(6400 * time.Millisecond),
 		},

client_test.go

@@ -90,14 +90,14 @@ func TestClientSession(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	require.NoError(t, err)
 
-	_, _, _, err = conn.Describe(u)
+	_, _, _, err = c.Describe(u)
 	require.NoError(t, err)
 }
 
@@ -171,14 +171,14 @@ func TestClientAuth(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	require.NoError(t, err)
 
-	_, _, _, err = conn.Describe(u)
+	_, _, _, err = c.Describe(u)
 	require.NoError(t, err)
 }
 
@@ -235,13 +235,13 @@ func TestClientDescribeCharset(t *testing.T) {
 
 	c := Client{}
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	require.NoError(t, err)
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	require.NoError(t, err)
 
-	_, _, _, err = conn.Describe(u)
+	_, _, _, err = c.Describe(u)
 	require.NoError(t, err)
 }

clientudpl.go

@@ -15,7 +15,7 @@ import (
 
 const (
 	// use the same buffer size as gstreamer's rtspsrc
-	clientConnUDPKernelReadBufferSize = 0x80000
+	clientUDPKernelReadBufferSize = 0x80000
 )
 
 func randUint32() uint32 {
@@ -29,7 +29,7 @@ func randIntn(n int) int {
 }
 
 type clientUDPListener struct {
-	cc            *ClientConn
+	c             *Client
 	pc            *net.UDPConn
 	remoteReadIP  net.IP
 	remoteWriteIP net.IP
@@ -46,18 +46,18 @@ type clientUDPListener struct {
 	done chan struct{}
 }
 
-func newClientUDPListenerPair(cc *ClientConn) (*clientUDPListener, *clientUDPListener) {
+func newClientUDPListenerPair(c *Client) (*clientUDPListener, *clientUDPListener) {
 	// choose two consecutive ports in range 65535-10000
 	// rtp must be even and rtcp odd
 	for {
 		rtpPort := (randIntn((65535-10000)/2) * 2) + 10000
-		rtpListener, err := newClientUDPListener(cc, false, ":"+strconv.FormatInt(int64(rtpPort), 10))
+		rtpListener, err := newClientUDPListener(c, false, ":"+strconv.FormatInt(int64(rtpPort), 10))
 		if err != nil {
 			continue
 		}
 
 		rtcpPort := rtpPort + 1
-		rtcpListener, err := newClientUDPListener(cc, false, ":"+strconv.FormatInt(int64(rtcpPort), 10))
+		rtcpListener, err := newClientUDPListener(c, false, ":"+strconv.FormatInt(int64(rtcpPort), 10))
 		if err != nil {
 			rtpListener.close()
 			continue
@@ -67,7 +67,7 @@ func newClientUDPListenerPair(cc *ClientConn) (*clientUDPListener, *clientUDPLis
 	}
 }
 
-func newClientUDPListener(cc *ClientConn, multicast bool, address string) (*clientUDPListener, error) {
+func newClientUDPListener(c *Client, multicast bool, address string) (*clientUDPListener, error) {
 	var pc *net.UDPConn
 	if multicast {
 		host, port, err := net.SplitHostPort(address)
@@ -75,7 +75,7 @@ func newClientUDPListener(cc *ClientConn, multicast bool, address string) (*clie
 			return nil, err
 		}
 
-		tmp, err := cc.c.ListenPacket("udp", "224.0.0.0:"+port)
+		tmp, err := c.ListenPacket("udp", "224.0.0.0:"+port)
 		if err != nil {
 			return nil, err
 		}
@@ -101,22 +101,22 @@ func newClientUDPListener(cc *ClientConn, multicast bool, address string) (*clie
 
 		pc = tmp.(*net.UDPConn)
 	} else {
-		tmp, err := cc.c.ListenPacket("udp", address)
+		tmp, err := c.ListenPacket("udp", address)
 		if err != nil {
 			return nil, err
 		}
 		pc = tmp.(*net.UDPConn)
 	}
 
-	err := pc.SetReadBuffer(clientConnUDPKernelReadBufferSize)
+	err := pc.SetReadBuffer(clientUDPKernelReadBufferSize)
 	if err != nil {
 		return nil, err
 	}
 
 	return &clientUDPListener{
-		cc:          cc,
+		c:           c,
 		pc:          pc,
-		frameBuffer: multibuffer.New(uint64(cc.c.ReadBufferCount), uint64(cc.c.ReadBufferSize)),
+		frameBuffer: multibuffer.New(uint64(c.ReadBufferCount), uint64(c.ReadBufferSize)),
 		lastFrameTime: func() *int64 {
 			v := int64(0)
 			return &v
@@ -150,7 +150,7 @@ func (l *clientUDPListener) stop() {
 func (l *clientUDPListener) run() {
 	defer close(l.done)
 
-	if l.cc.state == clientConnStatePlay {
+	if l.c.state == clientStatePlay {
 		for {
 			buf := l.frameBuffer.Next()
 			n, addr, err := l.pc.ReadFrom(buf)
@@ -168,12 +168,12 @@ func (l *clientUDPListener) run() {
 			atomic.StoreInt64(l.lastFrameTime, now.Unix())
 
 			if l.streamType == StreamTypeRTP {
-				l.cc.tracks[l.trackID].rtcpReceiver.ProcessPacketRTP(now, buf[:n])
+				l.c.tracks[l.trackID].rtcpReceiver.ProcessPacketRTP(now, buf[:n])
 			} else {
-				l.cc.tracks[l.trackID].rtcpReceiver.ProcessPacketRTCP(now, buf[:n])
+				l.c.tracks[l.trackID].rtcpReceiver.ProcessPacketRTCP(now, buf[:n])
 			}
 
-			l.cc.pullReadCB()(l.trackID, l.streamType, buf[:n])
+			l.c.pullReadCB()(l.trackID, l.streamType, buf[:n])
 		}
 	} else { // record
 		for {
@@ -191,7 +191,7 @@ func (l *clientUDPListener) run() {
 
 			now := time.Now()
 			atomic.StoreInt64(l.lastFrameTime, now.Unix())
-			l.cc.pullReadCB()(l.trackID, l.streamType, buf[:n])
+			l.c.pullReadCB()(l.trackID, l.streamType, buf[:n])
 		}
 	}
 }
@@ -200,7 +200,7 @@ func (l *clientUDPListener) write(buf []byte) error {
 	l.writeMutex.Lock()
 	defer l.writeMutex.Unlock()
 
-	l.pc.SetWriteDeadline(time.Now().Add(l.cc.c.WriteTimeout))
+	l.pc.SetWriteDeadline(time.Now().Add(l.c.WriteTimeout))
 	_, err := l.pc.WriteTo(buf, &net.UDPAddr{
 		IP:   l.remoteWriteIP,
 		Zone: l.remoteZone,

examples/client-publish-aac/main.go

@@ -42,12 +42,12 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start publishing the track
-	conn, err := c.DialPublish("rtsp://localhost:8554/mystream",
+	err = c.DialPublish("rtsp://localhost:8554/mystream",
 		gortsplib.Tracks{track})
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	buf = make([]byte, 2048)
 	for {
@@ -58,7 +58,7 @@ func main() {
 		}
 
 		// route RTP packets to the server
-		err = conn.WritePacketRTP(0, buf[:n])
+		err = c.WritePacketRTP(0, buf[:n])
 		if err != nil {
 			panic(err)
 		}

examples/client-publish-h264/main.go

@@ -43,12 +43,12 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start publishing the track
-	conn, err := c.DialPublish("rtsp://localhost:8554/mystream",
+	err = c.DialPublish("rtsp://localhost:8554/mystream",
 		gortsplib.Tracks{track})
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	buf := make([]byte, 2048)
 	for {
@@ -59,7 +59,7 @@ func main() {
 		}
 
 		// route RTP packets to the server
-		err = conn.WritePacketRTP(0, buf[:n])
+		err = c.WritePacketRTP(0, buf[:n])
 		if err != nil {
 			panic(err)
 		}

examples/client-publish-options/main.go

@@ -52,12 +52,12 @@ func main() {
 	}
 
 	// connect to the server and start publishing the track
-	conn, err := c.DialPublish("rtsp://localhost:8554/mystream",
+	err = c.DialPublish("rtsp://localhost:8554/mystream",
 		gortsplib.Tracks{track})
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	buf := make([]byte, 2048)
 	for {
@@ -68,7 +68,7 @@ func main() {
 		}
 
 		// route RTP packets to the server
-		err = conn.WritePacketRTP(0, buf[:n])
+		err = c.WritePacketRTP(0, buf[:n])
 		if err != nil {
 			panic(err)
 		}

examples/client-publish-opus/main.go

@@ -42,12 +42,12 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start publishing the track
-	conn, err := c.DialPublish("rtsp://localhost:8554/mystream",
+	err = c.DialPublish("rtsp://localhost:8554/mystream",
 		gortsplib.Tracks{track})
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	buf = make([]byte, 2048)
 	for {
@@ -58,7 +58,7 @@ func main() {
 		}
 
 		// route RTP packets to the server
-		err = conn.WritePacketRTP(0, buf[:n])
+		err = c.WritePacketRTP(0, buf[:n])
 		if err != nil {
 			panic(err)
 		}

examples/client-publish-pause/main.go

@@ -45,12 +45,12 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start publishing the track
-	conn, err := c.DialPublish("rtsp://localhost:8554/mystream",
+	err = c.DialPublish("rtsp://localhost:8554/mystream",
 		gortsplib.Tracks{track})
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	for {
 		writerDone := make(chan struct{})
@@ -66,7 +66,7 @@ func main() {
 				}
 
 				// route RTP packets to the server
-				err = conn.WritePacketRTP(0, buf[:n])
+				err = c.WritePacketRTP(0, buf[:n])
 				if err != nil {
 					break
 				}
@@ -77,7 +77,7 @@ func main() {
 		time.Sleep(5 * time.Second)
 
 		// pause
-		_, err := conn.Pause()
+		_, err := c.Pause()
 		if err != nil {
 			panic(err)
 		}
@@ -89,7 +89,7 @@ func main() {
 		time.Sleep(5 * time.Second)
 
 		// record again
-		_, err = conn.Record()
+		_, err = c.Record()
 		if err != nil {
 			panic(err)
 		}

examples/client-query/main.go

@@ -19,18 +19,18 @@ func main() {
 
 	c := gortsplib.Client{}
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	if err != nil {
 		panic(err)
 	}
 
-	tracks, _, _, err := conn.Describe(u)
+	tracks, _, _, err := c.Describe(u)
 	if err != nil {
 		panic(err)
 	}

examples/client-read-h264-save-to-disk/main.go

@@ -28,16 +28,16 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start reading all tracks
-	conn, err := c.DialRead(inputStream)
+	err := c.DialRead(inputStream)
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	// find the H264 track
 	var h264TrackID int = -1
 	var h264Conf *gortsplib.TrackConfigH264
-	for i, track := range conn.Tracks() {
+	for i, track := range c.Tracks() {
 		if track.IsH264() {
 			h264TrackID = i
 			h264Conf, err = track.ExtractConfigH264()
@@ -74,7 +74,7 @@ func main() {
 	mux.SetPCRPID(256)
 
 	// read packets
-	err = conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+	err = c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 		if trackID != h264TrackID {
 			return
 		}

examples/client-read-h264/main.go

@@ -17,15 +17,15 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start reading all tracks
-	conn, err := c.DialRead("rtsp://localhost:8554/mystream")
+	err := c.DialRead("rtsp://localhost:8554/mystream")
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	// find the H264 track
 	h264Track := func() int {
-		for i, track := range conn.Tracks() {
+		for i, track := range c.Tracks() {
 			if track.IsH264() {
 				return i
 			}
@@ -41,7 +41,7 @@ func main() {
 	dec := rtph264.NewDecoder()
 
 	// read packets
-	err = conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+	err = c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 		if streamType != gortsplib.StreamTypeRTP {
 			return
 		}

examples/client-read-options/main.go

@@ -23,14 +23,14 @@ func main() {
 	}
 
 	// connect to the server and start reading all tracks
-	conn, err := c.DialRead("rtsp://localhost:8554/mystream")
+	err := c.DialRead("rtsp://localhost:8554/mystream")
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	// read packets
-	err = conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+	err = c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 		fmt.Printf("packet from track %d, type %v, size %d\n", trackID, streamType, len(payload))
 	})
 	panic(err)

examples/client-read-partial/main.go

@@ -21,18 +21,18 @@ func main() {
 
 	c := gortsplib.Client{}
 
-	conn, err := c.Dial(u.Scheme, u.Host)
+	err = c.Dial(u.Scheme, u.Host)
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
-	_, err = conn.Options(u)
+	_, err = c.Options(u)
 	if err != nil {
 		panic(err)
 	}
 
-	tracks, baseURL, _, err := conn.Describe(u)
+	tracks, baseURL, _, err := c.Describe(u)
 	if err != nil {
 		panic(err)
 	}
@@ -40,7 +40,7 @@ func main() {
 	// start reading only video tracks, skipping audio or application tracks
 	for _, t := range tracks {
 		if t.Media.MediaName.Media == "video" {
-			_, err := conn.Setup(headers.TransportModePlay, baseURL, t, 0, 0)
+			_, err := c.Setup(headers.TransportModePlay, baseURL, t, 0, 0)
 			if err != nil {
 				panic(err)
 			}
@@ -48,13 +48,13 @@ func main() {
 	}
 
 	// play setupped tracks
-	_, err = conn.Play(nil)
+	_, err = c.Play(nil)
 	if err != nil {
 		panic(err)
 	}
 
 	// read packets
-	err = conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+	err = c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 		fmt.Printf("packet from track %d, type %v, size %d\n", trackID, streamType, len(payload))
 	})
 	panic(err)

examples/client-read-pause/main.go

@@ -17,18 +17,18 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start reading all tracks
-	conn, err := c.DialRead("rtsp://localhost:8554/mystream")
+	err := c.DialRead("rtsp://localhost:8554/mystream")
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	for {
 		// read packets
 		done := make(chan struct{})
 		go func() {
 			defer close(done)
-			conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+			c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 				fmt.Printf("packet from track %d, type %v, size %d\n", trackID, streamType, len(payload))
 			})
 		}()
@@ -37,7 +37,7 @@ func main() {
 		time.Sleep(5 * time.Second)
 
 		// pause
-		_, err := conn.Pause()
+		_, err := c.Pause()
 		if err != nil {
 			panic(err)
 		}
@@ -49,7 +49,7 @@ func main() {
 		time.Sleep(5 * time.Second)
 
 		// play again
-		_, err = conn.Play(nil)
+		_, err = c.Play(nil)
 		if err != nil {
 			panic(err)
 		}

examples/client-read/main.go

@@ -13,14 +13,14 @@ func main() {
 	c := gortsplib.Client{}
 
 	// connect to the server and start reading all tracks
-	conn, err := c.DialRead("rtsp://localhost:8554/mystream")
+	err := c.DialRead("rtsp://localhost:8554/mystream")
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer c.Close()
 
 	// read packets
-	err = conn.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
+	err = c.ReadFrames(func(trackID int, streamType gortsplib.StreamType, payload []byte) {
 		fmt.Printf("packet from track %d, type %v, size %d\n", trackID, streamType, len(payload))
 	})
 	panic(err)