1
use std::collections::HashMap;
2
use std::time::Instant;
3
 
4
use super::Pacer;
5
use super::PaddingRequest;
6
use super::QueueState;
7
use crate::Reason;
8
use crate::pacer::PacerReason;
9
use crate::rtp_::{Bitrate, DataSize, MidRid, TwccClusterId};
10
 
11
/// A null pacer that doesn't pace.
12
#[derive(Debug)]
13
pub struct NullPacer {
14
    last_sends: HashMap<MidRid, Instant>,
15
    queue_states: Vec<QueueState>,
16
    needs_timeout_before_next_poll: bool,
17
}
18
 
19
impl Default for NullPacer {
20
    fn default() -> Self {
21
        Self {
22
            last_sends: HashMap::default(),
23
            queue_states: Vec::default(),
24
            needs_timeout_before_next_poll: true,
25
        }
26
    }
27
}
28
 
29
impl Pacer for NullPacer {
30
    fn set_pacing_rate(&mut self, _padding_bitrate: Bitrate) {
31
        // We don't care
32
    }
33
 
34
    fn set_padding_rate(&mut self, _padding_bitrate: Bitrate) {
35
        // We don't care
36
    }
37
    fn poll_timeout(&self) -> (Option<Instant>, Reason) {
38
        let time = if self.needs_timeout_before_next_poll {
39
            self.last_sends.values().min().copied()
40
        } else {
41
            None
42
        };
43
 
44
        (time, Reason::Pacer(PacerReason::Handle))
45
    }
46
 
47
    fn handle_timeout(
48
        &mut self,
49
        _now: Instant,
50
        iter: impl Iterator<Item = QueueState>,
51
    ) -> Option<PaddingRequest> {
52
        self.needs_timeout_before_next_poll = false;
53
        self.queue_states.clear();
54
        self.queue_states.extend(iter);
55
 
56
        None
57
    }
58
 
59
    fn poll_queue(&mut self) -> Option<(MidRid, Option<TwccClusterId>)> {
60
        let non_empty_queues = self
61
            .queue_states
62
            .iter()
63
            .filter(|q| q.snapshot.packet_count > 0);
64
        // Pick a queue using round robin, prioritize the least recently sent on queue.
65
        let to_send_on = non_empty_queues.min_by_key(|q| self.last_sends.get(&q.midrid));
66
 
67
        let result = to_send_on.map(|q| (q.midrid, None));
68
 
69
        if result.is_some() {
70
            self.needs_timeout_before_next_poll = true;
71
        }
72
 
73
        result
74
    }
75
 
76
    fn register_send(&mut self, now: Instant, _packet_size: DataSize, from: MidRid) {
77
        let e = self.last_sends.entry(from).or_insert(now);
78
        *e = now;
79
    }
80
 
81
    fn has_padding_queue(&self) -> bool {
82
        false
83
    }
84
}