webrtc 0.17.1

A pure Rust implementation of WebRTC API
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use super::*;

#[test]
fn test_h264_fmtp_parse() {
    let tests: Vec<(&str, &str, Box<dyn Fmtp>)> = vec![
        (
            "OneParam",
            "key-name=value",
            Box::new(H264Fmtp {
                parameters: [("key-name".to_owned(), "value".to_owned())]
                    .iter()
                    .cloned()
                    .collect(),
            }),
        ),
        (
            "OneParamWithWhiteSpeces",
            "\tkey-name=value ",
            Box::new(H264Fmtp {
                parameters: [("key-name".to_owned(), "value".to_owned())]
                    .iter()
                    .cloned()
                    .collect(),
            }),
        ),
        (
            "TwoParams",
            "key-name=value;key2=value2",
            Box::new(H264Fmtp {
                parameters: [
                    ("key-name".to_owned(), "value".to_owned()),
                    ("key2".to_owned(), "value2".to_owned()),
                ]
                .iter()
                .cloned()
                .collect(),
            }),
        ),
        (
            "TwoParamsWithWhiteSpeces",
            "key-name=value;  \n\tkey2=value2 ",
            Box::new(H264Fmtp {
                parameters: [
                    ("key-name".to_owned(), "value".to_owned()),
                    ("key2".to_owned(), "value2".to_owned()),
                ]
                .iter()
                .cloned()
                .collect(),
            }),
        ),
    ];

    for (name, input, expected) in tests {
        let f = parse("video/h264", input);
        assert_eq!(&f, &expected, "{name} failed");

        assert_eq!(f.mime_type(), "video/h264");
    }
}

#[test]
fn test_h264_fmtp_compare() {
    let consist_string: HashMap<bool, String> = [
        (true, "consist".to_owned()),
        (false, "inconsist".to_owned()),
    ]
    .iter()
    .cloned()
    .collect();

    let tests = vec![
        (
            "Equal",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            true,
        ),
        (
            "EqualWithWhitespaceVariants",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            "  level-asymmetry-allowed=1;  \npacketization-mode=1;\t\nprofile-level-id=42e01f",
            true,
        ),
        (
            "EqualWithCase",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            "level-asymmetry-allowed=1;packetization-mode=1;PROFILE-LEVEL-ID=42e01f",
            true,
        ),
        (
            "OneHasExtraParam",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            "packetization-mode=1;profile-level-id=42e01f",
            true,
        ),
        (
            "DifferentProfileLevelIDVersions",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
            "packetization-mode=1;profile-level-id=42e029",
            true,
        ),
        (
            "Inconsistent",
            "packetization-mode=1;profile-level-id=42e029",
            "packetization-mode=0;profile-level-id=42e029",
            false,
        ),
        (
            "Inconsistent_MissingPacketizationMode",
            "packetization-mode=1;profile-level-id=42e029",
            "profile-level-id=42e029",
            false,
        ),
        (
            "Inconsistent_MissingProfileLevelID",
            "packetization-mode=1;profile-level-id=42e029",
            "packetization-mode=1",
            false,
        ),
        (
            "Inconsistent_InvalidProfileLevelID",
            "packetization-mode=1;profile-level-id=42e029",
            "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=41e029",
            false,
        ),
    ];

    for (name, a, b, consist) in tests {
        let check = |a, b| {
            let aa = parse("video/h264", a);
            let bb = parse("video/h264", b);

            // test forward case here
            let c = aa.match_fmtp(&*bb);
            assert_eq!(
                c,
                consist,
                "{}: '{}' and '{}' are expected to be {:?}, but treated as {:?}",
                name,
                a,
                b,
                consist_string.get(&consist),
                consist_string.get(&c),
            );

            // test reverse case here
            let c = bb.match_fmtp(&*aa);
            assert_eq!(
                c,
                consist,
                "{}: '{}' and '{}' are expected to be {:?}, but treated as {:?}",
                name,
                a,
                b,
                consist_string.get(&consist),
                consist_string.get(&c),
            );
        };

        check(a, b);
    }
}