improve performance

client.go

@@ -214,6 +214,7 @@ type Client struct {
 	tracksByChannel    map[int]int
 	lastRange          *headers.Range
 	tcpReadBuffer      *multibuffer.MultiBuffer
+	tcpRTPPacketBuffer *rtpPacketMultiBuffer
 	writeMutex         sync.RWMutex // publish
 	writeFrameAllowed  bool         // publish
 	udpReportTimer     *time.Timer
@@ -760,14 +761,14 @@ func (c *Client) runReader() {
 					atomic.StoreInt64(c.tcpLastFrameTime, now.Unix())
 
 					if isRTP {
-						var pkt rtp.Packet
+						pkt := c.tcpRTPPacketBuffer.next()
 						err := pkt.Unmarshal(payload)
 						if err != nil {
 							return
 						}
 
-						c.tracks[trackID].rtcpReceiver.ProcessPacketRTP(now, &pkt)
-						c.OnPacketRTP(trackID, &pkt)
+						c.tracks[trackID].rtcpReceiver.ProcessPacketRTP(now, pkt)
+						c.OnPacketRTP(trackID, pkt)
 					} else {
 						packets, err := rtcp.Unmarshal(payload)
 						if err != nil {
@@ -1536,6 +1537,7 @@ func (c *Client) doSetup(
 	case TransportTCP:
 		if c.tcpReadBuffer == nil {
 			c.tcpReadBuffer = multibuffer.New(uint64(c.ReadBufferCount), uint64(c.ReadBufferSize))
+			c.tcpRTPPacketBuffer = newRTPPacketMultiBuffer(uint64(c.ReadBufferCount))
 		}
 
 		if c.tracksByChannel == nil {

serverconn.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/pion/rtcp"
-	"github.com/pion/rtp"
 
 	"github.com/aler9/gortsplib/pkg/base"
 	"github.com/aler9/gortsplib/pkg/liberrors"
@@ -44,6 +43,7 @@ type ServerConn struct {
 	tcpSession         *ServerSession
 	tcpFrameTimeout    bool
 	tcpReadBuffer      *multibuffer.MultiBuffer
+	tcpRTPPacketBuffer *rtpPacketMultiBuffer
 	tcpProcessFunc     func(int, bool, []byte)
 	tcpWriterRunning   bool
 
@@ -260,7 +260,7 @@ func (sc *ServerConn) tcpProcessPlay(trackID int, isRTP bool, payload []byte) {
 
 func (sc *ServerConn) tcpProcessRecord(trackID int, isRTP bool, payload []byte) {
 	if isRTP {
-		var pkt rtp.Packet
+		pkt := sc.tcpRTPPacketBuffer.next()
 		err := pkt.Unmarshal(payload)
 		if err != nil {
 			return
@@ -270,7 +270,7 @@ func (sc *ServerConn) tcpProcessRecord(trackID int, isRTP bool, payload []byte)
 			h.OnPacketRTP(&ServerHandlerOnPacketRTPCtx{
 				Session: sc.tcpSession,
 				TrackID: trackID,
-				Packet:  &pkt,
+				Packet:  pkt,
 			})
 		}
 	} else {

serversession.go

@@ -1019,6 +1019,7 @@ func (ss *ServerSession) handleRequest(sc *ServerConn, req *base.Request) (*base
 			ss.tcpConn.tcpFrameEnabled = true
 			ss.tcpConn.tcpFrameTimeout = true
 			ss.tcpConn.tcpReadBuffer = multibuffer.New(uint64(sc.s.ReadBufferCount), uint64(sc.s.ReadBufferSize))
+			ss.tcpConn.tcpRTPPacketBuffer = newRTPPacketMultiBuffer(uint64(sc.s.ReadBufferCount))
 			ss.tcpConn.tcpProcessFunc = sc.tcpProcessRecord
 
 			// when recording, writeBuffer is only used to send RTCP receiver reports,

serverudpl.go

@@ -15,6 +15,26 @@ import (
 	"github.com/aler9/gortsplib/pkg/multibuffer"
 )
 
+type rtpPacketMultiBuffer struct {
+	count   uint64
+	buffers []rtp.Packet
+	cur     uint64
+}
+
+func newRTPPacketMultiBuffer(count uint64) *rtpPacketMultiBuffer {
+	buffers := make([]rtp.Packet, count)
+	return &rtpPacketMultiBuffer{
+		count:   count,
+		buffers: buffers,
+	}
+}
+
+func (mb *rtpPacketMultiBuffer) next() *rtp.Packet {
+	ret := &mb.buffers[mb.cur%mb.count]
+	mb.cur++
+	return ret
+}
+
 type clientData struct {
 	ss           *ServerSession
 	trackID      int
@@ -45,6 +65,7 @@ type serverUDPListener struct {
 	isRTP           bool
 	writeTimeout    time.Duration
 	readBuffer      *multibuffer.MultiBuffer
+	rtpPacketBuffer *rtpPacketMultiBuffer
 	clientsMutex    sync.RWMutex
 	clients         map[clientAddr]*clientData
 	processFunc     func(*clientData, []byte)
@@ -142,6 +163,7 @@ func newServerUDPListener(
 		isRTP:           isRTP,
 		writeTimeout:    s.WriteTimeout,
 		readBuffer:      multibuffer.New(uint64(s.ReadBufferCount), uint64(s.ReadBufferSize)),
+		rtpPacketBuffer: newRTPPacketMultiBuffer(uint64(s.ReadBufferCount)),
 		readerDone:      make(chan struct{}),
 	}
 
@@ -196,7 +218,7 @@ func (u *serverUDPListener) runReader() {
 }
 
 func (u *serverUDPListener) processRTP(clientData *clientData, payload []byte) {
-	var pkt rtp.Packet
+	pkt := u.rtpPacketBuffer.next()
 	err := pkt.Unmarshal(payload)
 	if err != nil {
 		return
@@ -204,13 +226,13 @@ func (u *serverUDPListener) processRTP(clientData *clientData, payload []byte) {
 
 	now := time.Now()
 	atomic.StoreInt64(clientData.ss.udpLastFrameTime, now.Unix())
-	clientData.ss.announcedTracks[clientData.trackID].rtcpReceiver.ProcessPacketRTP(now, &pkt)
+	clientData.ss.announcedTracks[clientData.trackID].rtcpReceiver.ProcessPacketRTP(now, pkt)
 
 	if h, ok := u.s.Handler.(ServerHandlerOnPacketRTP); ok {
 		h.OnPacketRTP(&ServerHandlerOnPacketRTPCtx{
 			Session: clientData.ss,
 			TrackID: clientData.trackID,
-			Packet:  &pkt,
+			Packet:  pkt,
 		})
 	}
 }