oxpulse-sfu-kit 0.8.0

Reusable multi-client SFU kit built on top of str0m. Simulcast, fanout, per-peer event routing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! Keyframe request wrapper.
//!
//! Public surface over `str0m::media::KeyframeRequest` and
//! `str0m::media::KeyframeRequestKind` so downstream consumers don't depend
//! on str0m's type semver.

use crate::ids::{SfuMid, SfuRid};

/// The two keyframe-request mechanisms RTCP supports.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SfuKeyframeKind {
    /// Picture Loss Indication — lightweight, most common.
    Pli,
    /// Full Intra Request — heavier, used when PLI is unsupported.
    Fir,
}

impl SfuKeyframeKind {
    #[allow(dead_code)]
    pub(crate) fn from_str0m(k: str0m::media::KeyframeRequestKind) -> Self {
        match k {
            str0m::media::KeyframeRequestKind::Pli => Self::Pli,
            str0m::media::KeyframeRequestKind::Fir => Self::Fir,
        }
    }
    #[allow(dead_code)]
    pub(crate) fn to_str0m(self) -> str0m::media::KeyframeRequestKind {
        match self {
            Self::Pli => str0m::media::KeyframeRequestKind::Pli,
            Self::Fir => str0m::media::KeyframeRequestKind::Fir,
        }
    }
}

/// A keyframe request arriving from a subscriber, destined for a publisher.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SfuKeyframeRequest {
    mid: SfuMid,
    rid: Option<SfuRid>,
    kind: SfuKeyframeKind,
}

impl SfuKeyframeRequest {
    /// Media stream this request targets on the publisher.
    pub fn mid(&self) -> SfuMid {
        self.mid
    }
    /// Simulcast layer this request targets, if simulcast is in use.
    pub fn rid(&self) -> Option<SfuRid> {
        self.rid
    }
    /// The RTCP mechanism (PLI or FIR).
    pub fn kind(&self) -> SfuKeyframeKind {
        self.kind
    }

    #[allow(dead_code)]
    pub(crate) fn from_str0m(r: str0m::media::KeyframeRequest) -> Self {
        Self {
            mid: SfuMid::from_str0m(r.mid),
            rid: r.rid.map(SfuRid::from_str0m),
            kind: SfuKeyframeKind::from_str0m(r.kind),
        }
    }
}

#[cfg(any(test, feature = "test-utils"))]
impl SfuKeyframeRequest {
    /// Construct a keyframe request for tests.
    ///
    /// Bypasses the str0m conversion path — use only in unit/integration tests.
    pub fn new_for_tests(mid: SfuMid, rid: Option<SfuRid>, kind: SfuKeyframeKind) -> Self {
        Self { mid, rid, kind }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn kind_roundtrip() {
        for k in [
            str0m::media::KeyframeRequestKind::Pli,
            str0m::media::KeyframeRequestKind::Fir,
        ] {
            let wrapped = SfuKeyframeKind::from_str0m(k);
            assert_eq!(wrapped.to_str0m(), k);
        }
    }
}