rtmp client: speed up closing

internal/connrtmp/conn.go

@@ -73,11 +73,12 @@ type Conn struct {
 	pathMan             PathMan
 	parent              Parent
 
-	// read mode
+	path       readpublisher.Path
-	ringBuffer *ringbuffer.RingBuffer
+	ringBuffer *ringbuffer.RingBuffer // read
 
 	// in
-	terminate chan struct{}
+	terminate       chan struct{}
+	parentTerminate chan struct{}
 }
 
 // New allocates a Conn.
@@ -106,7 +107,8 @@ func New(
 		conn:                rtmp.NewServerConn(nconn),
 		pathMan:             pathMan,
 		parent:              parent,
-		terminate:           make(chan struct{}),
+		terminate:           make(chan struct{}, 1),
+		parentTerminate:     make(chan struct{}),
 	}
 
 	c.log(logger.Info, "opened")
@@ -117,15 +119,18 @@ func New(
 	return c
 }
 
-// Close closes a Conn.
+// ParentClose closes a Conn.
-func (c *Conn) Close() {
+func (c *Conn) ParentClose() {
 	c.log(logger.Info, "closed")
-	close(c.terminate)
+	close(c.parentTerminate)
 }
 
-// RequestClose closes a Conn.
+// Close closes a Conn.
-func (c *Conn) RequestClose() {
+func (c *Conn) Close() {
-	c.parent.OnConnClose(c)
+	select {
+	case c.terminate <- struct{}{}:
+	default:
+	}
 }
 
 // IsReadPublisher implements readpublisher.ReadPublisher.
@@ -154,443 +159,352 @@ func (c *Conn) run() {
 		defer onConnectCmd.Close()
 	}
 
-	c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
+	c.ringBuffer = ringbuffer.New(uint64(c.readBufferCount))
-	c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
+
-	err := c.conn.ServerHandshake()
+	connErr := make(chan error)
-	if err != nil {
+	go func() {
-		c.log(logger.Info, "ERR: %s", err)
+		connErr <- func() error {
+			c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
+			c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
+			err := c.conn.ServerHandshake()
+			if err != nil {
+				return err
+			}
+
+			if c.conn.IsPublishing() {
+				return c.runPublish()
+			}
+			return c.runRead()
+		}()
+	}()
+
+	select {
+	case err := <-connErr:
+		if err != io.EOF {
+			c.log(logger.Info, "ERR: %s", err)
+		}
+
 		c.conn.NetConn().Close()
 
-		c.parent.OnConnClose(c)
+	case <-c.terminate:
-		<-c.terminate
+		c.ringBuffer.Close()
-		return
+		c.conn.NetConn().Close()
+		<-connErr
 	}
 
-	if c.conn.IsPublishing() {
+	if c.path != nil {
-		c.runPublish()
+		res := make(chan struct{})
-	} else {
+		c.path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
-		c.runRead()
+		<-res
 	}
+
+	c.parent.OnConnClose(c)
+	<-c.parentTerminate
 }
 
-func (c *Conn) runRead() {
+func (c *Conn) runRead() error {
-	var path readpublisher.Path
+	pathName, query := pathNameAndQuery(c.conn.URL())
+
+	sres := make(chan readpublisher.SetupPlayRes)
+	c.pathMan.OnReadPublisherSetupPlay(readpublisher.SetupPlayReq{
+		Author:   c,
+		PathName: pathName,
+		IP:       c.ip(),
+		ValidateCredentials: func(authMethods []headers.AuthMethod, pathUser string, pathPass string) error {
+			return c.validateCredentials(pathUser, pathPass, query)
+		},
+		Res: sres})
+	res := <-sres
+
+	if res.Err != nil {
+		if _, ok := res.Err.(readpublisher.ErrAuthCritical); ok {
+			// wait some seconds to stop brute force attacks
+			<-time.After(pauseAfterAuthError)
+		}
+		return res.Err
+	}
+
+	c.path = res.Path
+
 	var videoTrack *gortsplib.Track
 	var h264Decoder *rtph264.Decoder
 	var audioTrack *gortsplib.Track
 	var audioClockRate int
 	var aacDecoder *rtpaac.Decoder
 
-	err := func() error {
+	for i, t := range res.Tracks {
-		pathName, query := pathNameAndQuery(c.conn.URL())
+		if t.IsH264() {
-
+			if videoTrack != nil {
-		sres := make(chan readpublisher.SetupPlayRes)
+				return fmt.Errorf("can't read track %d with RTMP: too many tracks", i+1)
-		c.pathMan.OnReadPublisherSetupPlay(readpublisher.SetupPlayReq{
-			Author:   c,
-			PathName: pathName,
-			IP:       c.ip(),
-			ValidateCredentials: func(authMethods []headers.AuthMethod, pathUser string, pathPass string) error {
-				return c.validateCredentials(pathUser, pathPass, query)
-			},
-			Res: sres})
-		res := <-sres
-
-		if res.Err != nil {
-			if _, ok := res.Err.(readpublisher.ErrAuthCritical); ok {
-				// wait some seconds to stop brute force attacks
-				select {
-				case <-time.After(pauseAfterAuthError):
-				case <-c.terminate:
-				}
 			}
-			return res.Err
-		}
 
-		path = res.Path
+			videoTrack = t
-
+			h264Decoder = rtph264.NewDecoder()
-		for i, t := range res.Tracks {
-			if t.IsH264() {
-				if videoTrack != nil {
-					return fmt.Errorf("can't read track %d with RTMP: too many tracks", i+1)
-				}
 
-				videoTrack = t
+		} else if t.IsAAC() {
-				h264Decoder = rtph264.NewDecoder()
+			if audioTrack != nil {
-
+				return fmt.Errorf("can't read track %d with RTMP: too many tracks", i+1)
-			} else if t.IsAAC() {
-				if audioTrack != nil {
-					return fmt.Errorf("can't read track %d with RTMP: too many tracks", i+1)
-				}
-
-				audioTrack = t
-				audioClockRate, _ = audioTrack.ClockRate()
-				aacDecoder = rtpaac.NewDecoder(audioClockRate)
 			}
-		}
 
-		if videoTrack == nil && audioTrack == nil {
+			audioTrack = t
-			return fmt.Errorf("unable to find a video or audio track")
+			audioClockRate, _ = audioTrack.ClockRate()
-		}
+			aacDecoder = rtpaac.NewDecoder(audioClockRate)
-
-		c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
-		c.conn.WriteMetadata(videoTrack, audioTrack)
-
-		return nil
-	}()
-	if err != nil {
-		c.conn.NetConn().Close()
-		c.log(logger.Info, "ERR: %v", err)
-
-		if path != nil {
-			res := make(chan struct{})
-			path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
-			<-res
 		}
+	}
 
-		c.parent.OnConnClose(c)
+	if videoTrack == nil && audioTrack == nil {
-		<-c.terminate
+		return fmt.Errorf("unable to find a video or audio track")
-		return
 	}
 
-	c.ringBuffer = ringbuffer.New(uint64(c.readBufferCount))
+	c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
+	c.conn.WriteMetadata(videoTrack, audioTrack)
 
 	pres := make(chan readpublisher.PlayRes)
-	path.OnReadPublisherPlay(readpublisher.PlayReq{c, pres}) //nolint:govet
+	c.path.OnReadPublisherPlay(readpublisher.PlayReq{c, pres}) //nolint:govet
 	<-pres
 
-	c.log(logger.Info, "is reading from path '%s'", path.Name())
+	c.log(logger.Info, "is reading from path '%s'", c.path.Name())
 
 	// disable read deadline
 	c.conn.NetConn().SetReadDeadline(time.Time{})
 
-	writerDone := make(chan error)
+	var videoBuf [][]byte
-	go func() {
+	videoDTSEst := h264.NewDTSEstimator()
-		writerDone <- func() error {
+
-			var videoBuf [][]byte
+	for {
-			videoDTSEst := h264.NewDTSEstimator()
+		data, ok := c.ringBuffer.Pull()
-
+		if !ok {
-			for {
+			return fmt.Errorf("terminated")
-				data, ok := c.ringBuffer.Pull()
+		}
-				if !ok {
+		pair := data.(trackIDPayloadPair)
-					return fmt.Errorf("terminated")
+
+		if videoTrack != nil && pair.trackID == videoTrack.ID {
+			nalus, pts, err := h264Decoder.Decode(pair.buf)
+			if err != nil {
+				if err != rtph264.ErrMorePacketsNeeded {
+					c.log(logger.Warn, "unable to decode video track: %v", err)
 				}
-				pair := data.(trackIDPayloadPair)
+				continue
-
+			}
-				if videoTrack != nil && pair.trackID == videoTrack.ID {
+
-					nalus, pts, err := h264Decoder.Decode(pair.buf)
+			for _, nalu := range nalus {
-					if err != nil {
+				// remove SPS, PPS and AUD, not needed by RTSP
-						if err != rtph264.ErrMorePacketsNeeded {
+				typ := h264.NALUType(nalu[0] & 0x1F)
-							c.log(logger.Warn, "unable to decode video track: %v", err)
+				switch typ {
-						}
+				case h264.NALUTypeSPS, h264.NALUTypePPS, h264.NALUTypeAccessUnitDelimiter:
-						continue
+					continue
-					}
-
-					for _, nalu := range nalus {
-						// remove SPS, PPS and AUD, not needed by RTSP
-						typ := h264.NALUType(nalu[0] & 0x1F)
-						switch typ {
-						case h264.NALUTypeSPS, h264.NALUTypePPS, h264.NALUTypeAccessUnitDelimiter:
-							continue
-						}
-
-						videoBuf = append(videoBuf, nalu)
-					}
-
-					// RTP marker means that all the NALUs with the same PTS have been received.
-					// send them together.
-					marker := (pair.buf[1] >> 7 & 0x1) > 0
-					if marker {
-						data, err := h264.EncodeAVCC(videoBuf)
-						if err != nil {
-							return err
-						}
-
-						dts := videoDTSEst.Feed(pts + ptsOffset)
-						c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
-						err = c.conn.WritePacket(av.Packet{
-							Type:  av.H264,
-							Data:  data,
-							Time:  dts,
-							CTime: pts + ptsOffset - dts,
-						})
-						if err != nil {
-							return err
-						}
-
-						videoBuf = nil
-					}
-
-				} else if audioTrack != nil && pair.trackID == audioTrack.ID {
-					aus, pts, err := aacDecoder.Decode(pair.buf)
-					if err != nil {
-						if err != rtpaac.ErrMorePacketsNeeded {
-							c.log(logger.Warn, "unable to decode audio track: %v", err)
-						}
-						continue
-					}
-
-					for i, au := range aus {
-						auPTS := pts + ptsOffset + time.Duration(i)*1000*time.Second/time.Duration(audioClockRate)
-
-						c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
-						err := c.conn.WritePacket(av.Packet{
-							Type: av.AAC,
-							Data: au,
-							Time: auPTS,
-						})
-						if err != nil {
-							return err
-						}
-					}
 				}
+
+				videoBuf = append(videoBuf, nalu)
 			}
-		}()
-	}()
 
-	select {
+			// RTP marker means that all the NALUs with the same PTS have been received.
-	case err := <-writerDone:
+			// send them together.
-		c.conn.NetConn().Close()
+			marker := (pair.buf[1] >> 7 & 0x1) > 0
+			if marker {
+				data, err := h264.EncodeAVCC(videoBuf)
+				if err != nil {
+					return err
+				}
 
-		if err != io.EOF {
+				dts := videoDTSEst.Feed(pts + ptsOffset)
-			c.log(logger.Info, "ERR: %s", err)
+				c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
-		}
+				err = c.conn.WritePacket(av.Packet{
+					Type:  av.H264,
+					Data:  data,
+					Time:  dts,
+					CTime: pts + ptsOffset - dts,
+				})
+				if err != nil {
+					return err
+				}
 
-		res := make(chan struct{})
+				videoBuf = nil
-		path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
+			}
-		<-res
 
-		c.parent.OnConnClose(c)
+		} else if audioTrack != nil && pair.trackID == audioTrack.ID {
-		<-c.terminate
+			aus, pts, err := aacDecoder.Decode(pair.buf)
+			if err != nil {
+				if err != rtpaac.ErrMorePacketsNeeded {
+					c.log(logger.Warn, "unable to decode audio track: %v", err)
+				}
+				continue
+			}
 
-	case <-c.terminate:
+			for i, au := range aus {
-		res := make(chan struct{})
+				auPTS := pts + ptsOffset + time.Duration(i)*1000*time.Second/time.Duration(audioClockRate)
-		path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
-		<-res
 
-		c.ringBuffer.Close()
+				c.conn.NetConn().SetWriteDeadline(time.Now().Add(c.writeTimeout))
-		c.conn.NetConn().Close()
+				err := c.conn.WritePacket(av.Packet{
-		<-writerDone
+					Type: av.AAC,
+					Data: au,
+					Time: auPTS,
+				})
+				if err != nil {
+					return err
+				}
+			}
+		}
 	}
 }
 
-func (c *Conn) runPublish() {
+func (c *Conn) runPublish() error {
-	var videoTrack *gortsplib.Track
+	c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
-	var audioTrack *gortsplib.Track
+	videoTrack, audioTrack, err := c.conn.ReadMetadata()
-	var err error
+	if err != nil {
+		return err
+	}
+
 	var tracks gortsplib.Tracks
 	var h264Encoder *rtph264.Encoder
 	var aacEncoder *rtpaac.Encoder
-	var path readpublisher.Path
 
-	setupDone := make(chan struct{})
+	if videoTrack != nil {
-	go func() {
+		h264Encoder = rtph264.NewEncoder(96, nil, nil, nil)
-		defer close(setupDone)
+		tracks = append(tracks, videoTrack)
-		err = func() error {
+	}
-			c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
-			videoTrack, audioTrack, err = c.conn.ReadMetadata()
-			if err != nil {
-				return err
-			}
 
-			if videoTrack != nil {
+	if audioTrack != nil {
-				h264Encoder = rtph264.NewEncoder(96, nil, nil, nil)
+		clockRate, _ := audioTrack.ClockRate()
-				tracks = append(tracks, videoTrack)
+		aacEncoder = rtpaac.NewEncoder(96, clockRate, nil, nil, nil)
-			}
+		tracks = append(tracks, audioTrack)
+	}
 
-			if audioTrack != nil {
+	for i, t := range tracks {
-				clockRate, _ := audioTrack.ClockRate()
+		t.ID = i
-				aacEncoder = rtpaac.NewEncoder(96, clockRate, nil, nil, nil)
+	}
-				tracks = append(tracks, audioTrack)
-			}
 
-			for i, t := range tracks {
+	pathName, query := pathNameAndQuery(c.conn.URL())
-				t.ID = i
+
-			}
+	resc := make(chan readpublisher.AnnounceRes)
+	c.pathMan.OnReadPublisherAnnounce(readpublisher.AnnounceReq{
+		Author:   c,
+		PathName: pathName,
+		Tracks:   tracks,
+		IP:       c.ip(),
+		ValidateCredentials: func(authMethods []headers.AuthMethod, pathUser string, pathPass string) error {
+			return c.validateCredentials(pathUser, pathPass, query)
+		},
+		Res: resc,
+	})
+	res := <-resc
+
+	if res.Err != nil {
+		if _, ok := res.Err.(readpublisher.ErrAuthCritical); ok {
+			// wait some seconds to stop brute force attacks
+			<-time.After(pauseAfterAuthError)
+		}
+		return res.Err
+	}
 
-			pathName, query := pathNameAndQuery(c.conn.URL())
+	c.path = res.Path
-
-			resc := make(chan readpublisher.AnnounceRes)
-			c.pathMan.OnReadPublisherAnnounce(readpublisher.AnnounceReq{
-				Author:   c,
-				PathName: pathName,
-				Tracks:   tracks,
-				IP:       c.ip(),
-				ValidateCredentials: func(authMethods []headers.AuthMethod, pathUser string, pathPass string) error {
-					return c.validateCredentials(pathUser, pathPass, query)
-				},
-				Res: resc,
-			})
-			res := <-resc
-
-			if res.Err != nil {
-				if _, ok := res.Err.(readpublisher.ErrAuthCritical); ok {
-					// wait some seconds to stop brute force attacks
-					select {
-					case <-time.After(pauseAfterAuthError):
-					case <-c.terminate:
-					}
-				}
-				return res.Err
-			}
 
-			path = res.Path
+	// disable write deadline
-			return nil
+	c.conn.NetConn().SetWriteDeadline(time.Time{})
-		}()
-	}()
 
-	select {
+	rresc := make(chan readpublisher.RecordRes)
-	case <-setupDone:
+	c.path.OnReadPublisherRecord(readpublisher.RecordReq{Author: c, Res: rresc})
-	case <-c.terminate:
+	rres := <-rresc
-		c.conn.NetConn().Close()
+
-		<-setupDone
+	if rres.Err != nil {
+		return rres.Err
 	}
 
-	if err != nil {
+	c.log(logger.Info, "is publishing to path '%s', %d %s",
-		c.conn.NetConn().Close()
+		c.path.Name(),
-		c.log(logger.Info, "ERR: %s", err)
+		len(tracks),
+		func() string {
+			if len(tracks) == 1 {
+				return "track"
+			}
+			return "tracks"
+		}())
 
-		c.parent.OnConnClose(c)
+	var onPublishCmd *externalcmd.Cmd
-		<-c.terminate
+	if c.path.Conf().RunOnPublish != "" {
-		return
+		_, port, _ := net.SplitHostPort(c.rtspAddress)
+		onPublishCmd = externalcmd.New(c.path.Conf().RunOnPublish,
+			c.path.Conf().RunOnPublishRestart, externalcmd.Environment{
+				Path: c.path.Name(),
+				Port: port,
+			})
 	}
 
-	// disable write deadline
+	defer func(path readpublisher.Path) {
-	c.conn.NetConn().SetWriteDeadline(time.Time{})
+		if path.Conf().RunOnPublish != "" {
+			onPublishCmd.Close()
+		}
+	}(c.path)
 
-	readerDone := make(chan error)
+	rtcpSenders := rtcpsenderset.New(tracks, rres.SP.OnFrame)
-	go func() {
+	defer rtcpSenders.Close()
-		readerDone <- func() error {
-			resc := make(chan readpublisher.RecordRes)
-			path.OnReadPublisherRecord(readpublisher.RecordReq{Author: c, Res: resc})
-			res := <-resc
 
-			if res.Err != nil {
+	onFrame := func(trackID int, payload []byte) {
-				return res.Err
+		rtcpSenders.OnFrame(trackID, gortsplib.StreamTypeRTP, payload)
+		rres.SP.OnFrame(trackID, gortsplib.StreamTypeRTP, payload)
+	}
+
+	for {
+		c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
+		pkt, err := c.conn.ReadPacket()
+		if err != nil {
+			return err
+		}
+
+		switch pkt.Type {
+		case av.H264:
+			if videoTrack == nil {
+				return fmt.Errorf("ERR: received an H264 frame, but track is not set up")
 			}
 
-			c.log(logger.Info, "is publishing to path '%s', %d %s",
+			nalus, err := h264.DecodeAVCC(pkt.Data)
-				path.Name(),
+			if err != nil {
-				len(tracks),
+				return err
-				func() string {
-					if len(tracks) == 1 {
-						return "track"
-					}
-					return "tracks"
-				}())
-
-			var onPublishCmd *externalcmd.Cmd
-			if path.Conf().RunOnPublish != "" {
-				_, port, _ := net.SplitHostPort(c.rtspAddress)
-				onPublishCmd = externalcmd.New(path.Conf().RunOnPublish,
-					path.Conf().RunOnPublishRestart, externalcmd.Environment{
-						Path: path.Name(),
-						Port: port,
-					})
 			}
 
-			defer func(path readpublisher.Path) {
+			var outNALUs [][]byte
-				if path.Conf().RunOnPublish != "" {
-					onPublishCmd.Close()
-				}
-			}(path)
 
-			rtcpSenders := rtcpsenderset.New(tracks, res.SP.OnFrame)
+			for _, nalu := range nalus {
-			defer rtcpSenders.Close()
+				// remove SPS, PPS and AUD, not needed by RTSP
+				typ := h264.NALUType(nalu[0] & 0x1F)
+				switch typ {
+				case h264.NALUTypeSPS, h264.NALUTypePPS, h264.NALUTypeAccessUnitDelimiter:
+					continue
+				}
 
-			onFrame := func(trackID int, payload []byte) {
+				outNALUs = append(outNALUs, nalu)
-				rtcpSenders.OnFrame(trackID, gortsplib.StreamTypeRTP, payload)
-				res.SP.OnFrame(trackID, gortsplib.StreamTypeRTP, payload)
 			}
 
-			for {
+			if len(outNALUs) == 0 {
-				c.conn.NetConn().SetReadDeadline(time.Now().Add(c.readTimeout))
+				continue
-				pkt, err := c.conn.ReadPacket()
-				if err != nil {
-					return err
-				}
-
-				switch pkt.Type {
-				case av.H264:
-					if videoTrack == nil {
-						return fmt.Errorf("ERR: received an H264 frame, but track is not set up")
-					}
-
-					nalus, err := h264.DecodeAVCC(pkt.Data)
-					if err != nil {
-						return err
-					}
-
-					var outNALUs [][]byte
-
-					for _, nalu := range nalus {
-						// remove SPS, PPS and AUD, not needed by RTSP
-						typ := h264.NALUType(nalu[0] & 0x1F)
-						switch typ {
-						case h264.NALUTypeSPS, h264.NALUTypePPS, h264.NALUTypeAccessUnitDelimiter:
-							continue
-						}
-
-						outNALUs = append(outNALUs, nalu)
-					}
-
-					if len(outNALUs) == 0 {
-						continue
-					}
-
-					frames, err := h264Encoder.Encode(outNALUs, pkt.Time+pkt.CTime)
-					if err != nil {
-						return fmt.Errorf("ERR while encoding H264: %v", err)
-					}
-
-					for _, frame := range frames {
-						onFrame(videoTrack.ID, frame)
-					}
-
-				case av.AAC:
-					if audioTrack == nil {
-						return fmt.Errorf("ERR: received an AAC frame, but track is not set up")
-					}
-
-					frames, err := aacEncoder.Encode([][]byte{pkt.Data}, pkt.Time+pkt.CTime)
-					if err != nil {
-						return fmt.Errorf("ERR while encoding AAC: %v", err)
-					}
-
-					for _, frame := range frames {
-						onFrame(audioTrack.ID, frame)
-					}
-
-				default:
-					return fmt.Errorf("ERR: unexpected packet: %v", pkt.Type)
-				}
 			}
-		}()
-	}()
 
-	select {
+			frames, err := h264Encoder.Encode(outNALUs, pkt.Time+pkt.CTime)
-	case err := <-readerDone:
+			if err != nil {
-		c.conn.NetConn().Close()
+				return fmt.Errorf("ERR while encoding H264: %v", err)
+			}
 
-		if err != io.EOF {
+			for _, frame := range frames {
-			c.log(logger.Info, "ERR: %s", err)
+				onFrame(videoTrack.ID, frame)
-		}
+			}
 
-		res := make(chan struct{})
+		case av.AAC:
-		path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
+			if audioTrack == nil {
-		<-res
+				return fmt.Errorf("ERR: received an AAC frame, but track is not set up")
-		path = nil
+			}
 
-		c.parent.OnConnClose(c)
+			frames, err := aacEncoder.Encode([][]byte{pkt.Data}, pkt.Time+pkt.CTime)
-		<-c.terminate
+			if err != nil {
+				return fmt.Errorf("ERR while encoding AAC: %v", err)
+			}
 
-	case <-c.terminate:
+			for _, frame := range frames {
-		c.conn.NetConn().Close()
+				onFrame(audioTrack.ID, frame)
-		<-readerDone
+			}
 
-		res := make(chan struct{})
+		default:
-		path.OnReadPublisherRemove(readpublisher.RemoveReq{c, res}) //nolint:govet
+			return fmt.Errorf("ERR: unexpected packet: %v", pkt.Type)
-		<-res
+		}
-		path = nil
 	}
 }
 

internal/connrtsp/conn.go

@@ -95,8 +95,8 @@ func New(
 	return c
 }
 
-// Close closes a Conn.
+// ParentClose closes a Conn.
-func (c *Conn) Close(err error) {
+func (c *Conn) ParentClose(err error) {
 	if err != io.EOF && !isTeardownErr(err) && !isTerminatedErr(err) {
 		c.log(logger.Info, "ERR: %v", err)
 	}

internal/converterhls/converter.go

@@ -182,14 +182,14 @@ func New(
 	return c
 }
 
-// Close closes a Converter.
+// ParentClose closes a Converter.
-func (c *Converter) Close() {
+func (c *Converter) ParentClose() {
 	c.log(logger.Info, "closed")
 	close(c.terminate)
 }
 
-// RequestClose closes a Converter.
+// Close closes a Converter.
-func (c *Converter) RequestClose() {
+func (c *Converter) Close() {
 	c.parent.OnConverterClose(c)
 }
 

internal/path/path.go

@@ -309,7 +309,7 @@ outer:
 			case readPublisherStateRecord:
 				atomic.AddInt64(pa.stats.CountPublishers, -1)
 			}
-			c.RequestClose()
+			c.Close()
 		}
 	}
 	pa.readPublishersWg.Wait()
@@ -470,7 +470,7 @@ func (pa *Path) removeReadPublisher(c readpublisher.ReadPublisher) {
 		for oc, state := range pa.readPublishers {
 			if state != readPublisherStatePreRemove {
 				pa.removeReadPublisher(oc)
-				oc.RequestClose()
+				oc.Close()
 			}
 		}
 	}
@@ -510,7 +510,7 @@ func (pa *Path) onSourceSetNotReady() {
 	for c, state := range pa.readPublishers {
 		if c != pa.source && state != readPublisherStatePreRemove {
 			pa.removeReadPublisher(c)
-			c.RequestClose()
+			c.Close()
 		}
 	}
 }
@@ -661,10 +661,10 @@ func (pa *Path) onReadPublisherAnnounce(req readpublisher.AnnounceReq) {
 			return
 		}
 
-		pa.Log(logger.Info, "disconnecting existing publisher")
+		pa.Log(logger.Info, "closing existing publisher")
 		curPublisher := pa.source.(readpublisher.ReadPublisher)
 		pa.removeReadPublisher(curPublisher)
-		curPublisher.RequestClose()
+		curPublisher.Close()
 
 		// prevent path closure
 		if pa.closeTimerStarted {

internal/readpublisher/readpublisher.go

@@ -58,7 +58,6 @@ type ReadPublisher interface {
 	IsReadPublisher()
 	IsSource()
 	Close()
-	RequestClose()
 	OnFrame(int, gortsplib.StreamType, []byte)
 }
 

internal/serverhls/server.go

@@ -203,7 +203,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) doConverterClose(c *converterhls.Converter) {
 	delete(s.converters, c.PathName())
-	c.Close()
+	c.ParentClose()
 }
 
 // OnConverterClose is called by converterhls.Converter.

internal/serverrtmp/server.go

@@ -183,6 +183,7 @@ outer:
 
 func (s *Server) doConnClose(c *connrtmp.Conn) {
 	delete(s.conns, c)
+	c.ParentClose()
 	c.Close()
 }
 

internal/serverrtsp/server.go

@@ -221,7 +221,7 @@ func (s *Server) OnConnClose(ctx *gortsplib.ServerHandlerOnConnCloseCtx) {
 	delete(s.conns, ctx.Conn)
 	s.mutex.Unlock()
 
-	c.Close(ctx.Error)
+	c.ParentClose(ctx.Error)
 }
 
 // OnRequest implements gortsplib.ServerHandlerOnRequest.
@@ -270,7 +270,7 @@ func (s *Server) OnSessionClose(ctx *gortsplib.ServerHandlerOnSessionCloseCtx) {
 	delete(s.sessions, ctx.Session)
 	s.mutex.Unlock()
 
-	se.Close()
+	se.ParentClose()
 }
 
 // OnDescribe implements gortsplib.ServerHandlerOnDescribe.

internal/sessionrtsp/session.go

@@ -75,8 +75,8 @@ func New(
 	return s
 }
 
-// Close closes a Session.
+// ParentClose closes a Session.
-func (s *Session) Close() {
+func (s *Session) ParentClose() {
 	switch s.ss.State() {
 	case gortsplib.ServerSessionStatePlay:
 		if s.onReadCmd != nil {
@@ -99,8 +99,8 @@ func (s *Session) Close() {
 	s.log(logger.Info, "closed")
 }
 
-// RequestClose closes a Session.
+// Close closes a Session.
-func (s *Session) RequestClose() {
+func (s *Session) Close() {
 	s.ss.Close()
 }