[go: up one dir, main page]

rtp 0.8.0

A pure Rust implementation of RTP
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

use std::borrow::Cow;
use std::fmt;

use util::{Marshal, MarshalSize};

pub mod abs_send_time_extension;
pub mod audio_level_extension;
pub mod transport_cc_extension;
pub mod video_orientation_extension;

/// A generic RTP header extension.
pub enum HeaderExtension {
    AbsSendTime(abs_send_time_extension::AbsSendTimeExtension),
    AudioLevel(audio_level_extension::AudioLevelExtension),
    TransportCc(transport_cc_extension::TransportCcExtension),
    VideoOrientation(video_orientation_extension::VideoOrientationExtension),

    /// A custom extension
    Custom {
        uri: Cow<'static, str>,
        extension: Box<dyn Marshal + Send + Sync + 'static>,
    },
}

impl HeaderExtension {
    pub fn uri(&self) -> Cow<'static, str> {
        use HeaderExtension::*;

        match self {
            AbsSendTime(_) => "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time".into(),
            AudioLevel(_) => "urn:ietf:params:rtp-hdrext:ssrc-audio-level".into(),
            TransportCc(_) => {
                "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01".into()
            }
            VideoOrientation(_) => "urn:3gpp:video-orientation".into(),
            Custom { uri, .. } => uri.clone(),
        }
    }

    pub fn is_same(&self, other: &Self) -> bool {
        use HeaderExtension::*;
        match (self, other) {
            (AbsSendTime(_), AbsSendTime(_)) => true,
            (AudioLevel(_), AudioLevel(_)) => true,
            (TransportCc(_), TransportCc(_)) => true,
            (VideoOrientation(_), VideoOrientation(_)) => true,
            (Custom { uri, .. }, Custom { uri: other_uri, .. }) => uri == other_uri,
            _ => false,
        }
    }
}

impl MarshalSize for HeaderExtension {
    fn marshal_size(&self) -> usize {
        use HeaderExtension::*;
        match self {
            AbsSendTime(ext) => ext.marshal_size(),
            AudioLevel(ext) => ext.marshal_size(),
            TransportCc(ext) => ext.marshal_size(),
            VideoOrientation(ext) => ext.marshal_size(),
            Custom { extension: ext, .. } => ext.marshal_size(),
        }
    }
}

impl Marshal for HeaderExtension {
    fn marshal_to(&self, buf: &mut [u8]) -> util::Result<usize> {
        use HeaderExtension::*;
        match self {
            AbsSendTime(ext) => ext.marshal_to(buf),
            AudioLevel(ext) => ext.marshal_to(buf),
            TransportCc(ext) => ext.marshal_to(buf),
            VideoOrientation(ext) => ext.marshal_to(buf),
            Custom { extension: ext, .. } => ext.marshal_to(buf),
        }
    }
}

impl fmt::Debug for HeaderExtension {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use HeaderExtension::*;

        match self {
            AbsSendTime(ext) => f.debug_tuple("AbsSendTime").field(ext).finish(),
            AudioLevel(ext) => f.debug_tuple("AudioLevel").field(ext).finish(),
            TransportCc(ext) => f.debug_tuple("TransportCc").field(ext).finish(),
            VideoOrientation(ext) => f.debug_tuple("VideoOrientation").field(ext).finish(),
            Custom { uri, extension: _ } => f.debug_struct("Custom").field("uri", uri).finish(),
        }
    }
}