exponential backoff FIR requests

Author: lherman-cs

pulsebeam/src/participant/downstream/video.rs

@@ -415,7 +415,7 @@ struct Slot {
     switcher: Switcher,
     state: Option<SlotState>,
     switching_started_at: Option<Instant>,
-    keyframe_req_count: u32,
+    keyframe_retries: usize,
     waker: Option<Waker>,
 }
 
@@ -427,7 +427,7 @@ impl Slot {
             switcher: Switcher::new(rtp::VIDEO_FREQUENCY),
             state: Some(SlotState::Idle),
             switching_started_at: None,
-            keyframe_req_count: 0,
+            keyframe_retries: 0,
             waker: None,
         }
     }
@@ -472,7 +472,7 @@ impl Slot {
         receiver.channel.reset();
         receiver.request_keyframe(KeyframeRequestKind::Fir);
         self.switching_started_at = Some(Instant::now());
-        self.keyframe_req_count = 1;
+        self.keyframe_retries = 0;
 
         tracing::info!(
             mid = %self.mid,
@@ -549,32 +549,45 @@ impl Slot {
     }
 
     fn poll_slow(&mut self, now: Instant) {
+        const KEYFRAME_RETRY_DELAYS_MS: [u64; 4] = [500, 1000, 2000, 4000];
+
+        // Chrome shares keyframe request throttling for all simulcast streams &
+        // Our keyframe request might get lost in the middle. Retry some to at least
+        // reduce the probability to miss the keyframe.
         let Some(started_at) = self.switching_started_at else {
             return;
         };
 
-        if self.keyframe_req_count >= 5 {
+        if self.keyframe_retries >= KEYFRAME_RETRY_DELAYS_MS.len() {
             return;
         }
 
-        let deadline = started_at + Duration::from_secs(1) * self.keyframe_req_count;
+        let current_delay_ms = KEYFRAME_RETRY_DELAYS_MS[self.keyframe_retries];
+        let deadline = started_at + Duration::from_millis(current_delay_ms);
         if deadline > now {
             return;
         }
 
-        self.keyframe_req_count += 1;
-        let Some(receiver) = self.target_receiver() else {
-            return;
-        };
-        receiver.request_keyframe(KeyframeRequestKind::Fir);
+        self.keyframe_retries += 1;
+        if let Some(receiver) = self.target_receiver() {
+            tracing::warn!(
+                receiver = %receiver,
+                "Switch slow. Retrying keyframe request (attempt {}/{}). Elapsed: {:?}",
+                self.keyframe_retries,
+                KEYFRAME_RETRY_DELAYS_MS.len(),
+                now.duration_since(started_at)
+            );
+
+            receiver.request_keyframe(KeyframeRequestKind::Fir);
+        }
     }
 
     #[inline]
     fn transition_to(&mut self, new_state: SlotState) {
         match &new_state {
             SlotState::Streaming { .. } => {
                 self.switching_started_at = None;
-                self.keyframe_req_count = 0;
+                self.keyframe_retries = 0;
             }
             _ => {}
         }

pulsebeam/src/rtp/monitor.rs

@@ -591,11 +591,8 @@ impl DeltaDeltaState {
         }
 
         // Check if there's space in the buffer for this packet
-        // Using wrapping arithmetic: offset < capacity means it's in range
         let offset_from_tail = seq_val.wrapping_sub(tail_val);
         if offset_from_tail >= buffer_capacity {
-            // No space - need to slide the window
-            // process_until is now optimized to only check each buffer slot once
             let new_tail = self.head.wrapping_sub(buffer_capacity);
             self.process_until(new_tail.into());
         }

pulsebeam/src/track.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::pin::Pin;
 use std::{
     sync::Arc,
@@ -58,6 +59,16 @@ pub struct SimulcastReceiver {
     pub state: StreamState,
 }
 
+impl Display for SimulcastReceiver {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!(
+            "{}:{}",
+            self.meta.id,
+            self.rid.as_deref().unwrap_or("_")
+        ))
+    }
+}
+
 impl SimulcastReceiver {
     pub fn request_keyframe(&self, kind: KeyframeRequestKind) {
         if let Err(err) = self.keyframe_requester.try_send(kind) {