Packet retransmission in response to NACK

[Xosrov]

Hello and happy new year,
I am working on a webrtc pion-to-browser implementation on a server with high packet loss, thus I'm thinking i should utilize received NACKs and retransmit lost packets to fix this problem.
This is the basic workflow of the existing code(with help from preexisting examples):

• Read from static RTP stream(ffmpeg) and write to track:

// read rtp video packets from ffmpeg on some port
vListener, err = net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP(receiveIP), Port: receivePort})
if err != nil {
	panic(err)
}

// define video codec
var codec = webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeH264}

// define new track from local stream
videoTrack, err = webrtc.NewTrackLocalStaticRTP(vCodec, "video", vTrackName)
if err != nil {
panic(err)
}

// read maximum of RTCBufferSize from udp listener and write to track
go func() {
	inboundRTPPacket := make([]byte, RTCBufferSize)
	for {
		n, _, err := vListener.ReadFrom(inboundRTPPacket)
		if err != nil {
			break
		}
		if _, err = videoTrack.Write(inboundRTPPacket[:n]); err != nil {
			if errors.Is(err, io.ErrClosedPipe) {
				break
			}
			panic(err)
		}
	}
}()

• Use the previously defined track and stream to clients connecting to the pion server:

// create a MediaEngine object to configure the supported codec
m := &webrtc.MediaEngine{}

// setup the codecs to use
if err := m.RegisterCodec(webrtc.RTPCodecParameters{
	RTPCodecCapability: codec,
	PayloadType:        96,
}, webrtc.RTPCodecTypeVideo); err != nil {
	panic(err)
}

// enable interceptors for NACK/RTCP Reports support
i := &interceptor.Registry{}

// Use the default set of interceptors
if err := webrtc.RegisterDefaultInterceptors(m, i); err != nil {
panic(err)
}

// Create the API object with the MediaEngine
api := webrtc.NewAPI(webrtc.WithMediaEngine(m), webrtc.WithInterceptorRegistry(i))

// define configuration and create a new peerConnection
configuration = webrtc.Configuration{
	ICEServers: []webrtc.ICEServer{
		{
			URLs: []string{"stun:stun.l.google.com:19302"},
		},
	},
}
serverConnection, err := api.NewPeerConnection(configuration)
if err != nil {
panic(err)
}

• Read incoming RTCP packets. This is where i assume i need to aknowledge NACKs and make retransmissions:

// Add previously created track to peer connection
rtcpReader, err := serverConnection.AddTrack(videoTrack)
if err != nil {
panic(err)
}

// read maximum of RTCBufferSize from incoming RTCP packets and parse it
go func() {
	rtcpBuffer := make([]byte, RTCBufferSize)
	for {
		n, attributes, err := rtcpVReader.Read(rtcpBuffer)
		if err != nil {
			break
		}
		// detect NACK and retransmit lost packages(?)
	}
}()

---

Is there a streamlined way of retransmitting lost packets, or do i need to create an implementation myself? I've seen solutions like this about how to handle retransmission:

The main question here is if I should obey all the retransmission requests or not. The way this is implemented in Google's WebRTC implementation right now is this one:

1. Keep a copy of the packets sent in the last 1000 msecs (the "history").
2. When a NACK is received try to send the packets requests if we still have them in the history.
3. But... (rtp_sender.cc)

• Ignore the request if the packet has been resent in the last RTT msecs.
• Ignore the request if we are sending too many retransmissions. There is a rate limiter (retransmission_rate_limiter) that is apparently configured to the whole channel bandwidth estimation.
• If pacing is enabled insert this packet in the queue with normal priority.

I would love to hear any suggestions or other solutions to this problem. I would also appreciate if you could link me to any helpful resources or existing implementations to help with it.

Thank you for your time.