Add use case 3 for custom NACK/RTX

api-outline.md

@@ -124,6 +124,9 @@ interface RTCRtpSendStream {
   attribute EventHandler onpacketizedrtp;
   sequence<RTCRtpPacket> readPacketizedRtp(long maxNumberOfPackets);
 
+  attribute EventHandler onreceivedrtcpnacks;
+  sequence<RTCRtpNack> readReceivedRtcpNacks(long maxNumberOfPackets);
+
   // https://github.com/w3c/webrtc-rtptransport/issues/32
   void sendRtp(RTCRtpPacket packet);
   Promise<RTCRtpSendResult> sendRtp(RTCRtpPacketInit packet, RTCRtpSendOptions options);
@@ -152,6 +155,13 @@ enum RTCRtpUnsentReason {
 
 dictionary RTCRtpSendOptions {
   DOMHighResTimeStamp sendTime;
+  // Serializes the first two bytes of the RTP payload as an RTX payload
+  // and sends using the RTX ssrc.
+  bool asRtx;
+}
+
+interface RTCRtcpNack {
+  readonly attribute sequence<unsigned short> sequenceNumbers;
 }
 
 [Exposed=(Window,Worker), Transferable]
@@ -164,6 +174,8 @@ interface RTCRtpReceiveStream {
   attribute EventHandler onreceivedrtp;
   sequence<RTCRtpPacket> readReceivedRtp(long maxNumberOfPackets);
 
-  void receiveRtp(RTCRtpPacket packet)
+  void receiveRtp(RTCRtpPacket packet);
+
+  void sendNack(sequence<unsigned short>);
 }
 ```

explainer-use-case-1.md

@@ -260,7 +260,7 @@ setInterval(() => {
 }, 1000);
 ```
 
-## Example 13: Receive with BYOB
+### Example 13: Receive with BYOB
 ```javascript
 const [pc, videoRtpReceiver] = await setupPeerConnectionWithRtpReceiver();  // Custom
 const videoRtpReceiveStream = await videoRtpReceiver.replaceReceiveStreams()[0];  // Custom
@@ -274,7 +274,7 @@ videoRtpReceiveStream.onrtpreceived = () => {
 };
 ```
 
-## Example 14: Packetize with BYOB
+### Example 14: Packetize with BYOB
 ```javascript
 const [pc, videoRtpSender] = await setupPeerConnectionWithRtpSender();  // Custom
 const videoRtpSendStream = await videoRtpSender.replaceSendStreams()[0];

explainer-use-case-2.md

@@ -21,7 +21,7 @@ Applications can do custom bandwidth estimation via:
 
 ## Examples
 
-## Example 1: Custom BWE
+### Example 1: Custom BWE
 
 ```javascript
 const [pc, rtpTransport] = setupPeerConnectionWithRtpTransport();  // Custom
@@ -40,7 +40,7 @@ rtpTransport.onrtpacksreceived = (rtpAcks) => {
 
 ```
 
-## Example 2: Custom Pacing and Probing
+### Example 2: Custom Pacing and Probing
 
 ```javascript
 const [pc, rtpTransport] = setupPeerConnectionWithRtpTransport({customPacer: true});  // Custom
@@ -59,7 +59,7 @@ while (true) {
 }
 ```
 
-## Example 3: Batched pacing
+### Example 3: Batched pacing
 Making use of the synchronous readPacketizedRtp method to only read packets in batches
 at a controlled frequency.
 

explainer-use-case-3.md

@@ -0,0 +1,54 @@
+# Custom RTX Use Case
+
+## Motivation
+
+Advanced web applications wish to control NACK and RTX behavior, such as being able to control how large the RTX packet cache is, or how long packets stay in the cache.
+
+## Examples
+
+### Example: Custom RTX packet cache
+
+```javascript
+const [pc, rtpTransport, rtpSender] = setupPeerConnectionWithRtpTransport();  // Custom
+const rtxPacketCache = createRtxPacketCache();  // Custom
+const rtpSendStream = await rtpSender.replaceSendStreams()[0];
+rtpSendStream.onpacketizedrtp = () => {
+  const rtpPackets = rtpSendStream.readPacketizedRtp();
+  for (const rtpPacket of rtpPackets) {
+    rtxPacketCache.cacheRtpPacket(rtpPacket);
+    rtpSendStream.sendRtp(rtpPacket);
+  }
+};
+// TODO: How do we disable normal NACK processing?  
+rtpSendStream.onreceivedrtcpnacks = () => {
+    const nacks = rtpSendStream.readReceivedRtcpNacks();
+    for (const nack of nacks) {
+        for (const seqnum of nack.sequenceNumbers) {
+            const cachedRtpPacket = rtxPacketCache.getCachedRtpPacketBySequenceNumber(seqnum);
+            if (cachedRtpPacket) {
+                rtpSendStream.sendRtp(cachedRtpPacket, {asRtx: true});
+            }
+        }
+    }
+}
+```
+
+### Example: Custom NACK
+
+```javascript
+const [pc, rtpTransport, rtpReceiver] = setupPeerConnectionWithRtpTransport();  // Custom
+const nackCalculator = createNackCalculator();  // Custom
+const rtpReceiveStream = await rtpReceiver.replaceReceiveStreams()[0];
+// TODO: How do we disable normal NACK sending?
+rtpReceiveStream.onrtpreceived = () => {
+  const rtpPacket = rtpReceiveStream.readReceivedRtp();
+  const nackedSequenceNumbers = nackCalaculator.calculateNackedSequenceNumbers(rtpPacket);
+  if (nackedSequenceNumbers) {
+    rtpRecieveStream.sendNack(nackedSequenceNumbers);
+  }
+}
+```
+
+### Example: Custom RTX payload
+
+TODO