stream_params_unittest.cc (10572B)
1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "media/base/stream_params.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <string> 16 #include <vector> 17 18 #include "api/array_view.h" 19 #include "media/base/test_utils.h" 20 #include "rtc_base/unique_id_generator.h" 21 #include "test/gmock.h" 22 #include "test/gtest.h" 23 24 using ::testing::Each; 25 using ::testing::Ne; 26 27 static const uint32_t kSsrcs1[] = {1}; 28 static const uint32_t kSsrcs2[] = {1, 2}; 29 30 static webrtc::StreamParams CreateStreamParamsWithSsrcGroup( 31 const std::string& semantics, 32 webrtc::ArrayView<const uint32_t> ssrcs_in) { 33 webrtc::StreamParams stream; 34 std::vector<uint32_t> ssrcs(ssrcs_in.begin(), ssrcs_in.end()); 35 webrtc::SsrcGroup sg(semantics, ssrcs); 36 stream.ssrcs = ssrcs; 37 stream.ssrc_groups.push_back(sg); 38 return stream; 39 } 40 41 TEST(SsrcGroup, EqualNotEqual) { 42 webrtc::SsrcGroup ssrc_groups[] = { 43 webrtc::SsrcGroup("ABC", MAKE_VECTOR(kSsrcs1)), 44 webrtc::SsrcGroup("ABC", MAKE_VECTOR(kSsrcs2)), 45 webrtc::SsrcGroup("Abc", MAKE_VECTOR(kSsrcs2)), 46 webrtc::SsrcGroup("abc", MAKE_VECTOR(kSsrcs2)), 47 }; 48 49 for (size_t i = 0; i < std::size(ssrc_groups); ++i) { 50 for (size_t j = 0; j < std::size(ssrc_groups); ++j) { 51 EXPECT_EQ((ssrc_groups[i] == ssrc_groups[j]), (i == j)); 52 EXPECT_EQ((ssrc_groups[i] != ssrc_groups[j]), (i != j)); 53 } 54 } 55 } 56 57 TEST(SsrcGroup, HasSemantics) { 58 webrtc::SsrcGroup sg1("ABC", MAKE_VECTOR(kSsrcs1)); 59 EXPECT_TRUE(sg1.has_semantics("ABC")); 60 61 webrtc::SsrcGroup sg2("Abc", MAKE_VECTOR(kSsrcs1)); 62 EXPECT_FALSE(sg2.has_semantics("ABC")); 63 64 webrtc::SsrcGroup sg3("abc", MAKE_VECTOR(kSsrcs1)); 65 EXPECT_FALSE(sg3.has_semantics("ABC")); 66 } 67 68 TEST(SsrcGroup, ToString) { 69 webrtc::SsrcGroup sg1("ABC", MAKE_VECTOR(kSsrcs1)); 70 EXPECT_STREQ("{semantics:ABC;ssrcs:[1]}", sg1.ToString().c_str()); 71 } 72 73 TEST(StreamParams, CreateLegacy) { 74 const uint32_t ssrc = 7; 75 webrtc::StreamParams one_sp = webrtc::StreamParams::CreateLegacy(ssrc); 76 EXPECT_EQ(1U, one_sp.ssrcs.size()); 77 EXPECT_EQ(ssrc, one_sp.first_ssrc()); 78 EXPECT_TRUE(one_sp.has_ssrcs()); 79 EXPECT_TRUE(one_sp.has_ssrc(ssrc)); 80 EXPECT_FALSE(one_sp.has_ssrc(ssrc + 1)); 81 EXPECT_FALSE(one_sp.has_ssrc_groups()); 82 EXPECT_EQ(0U, one_sp.ssrc_groups.size()); 83 } 84 85 TEST(StreamParams, HasSsrcGroup) { 86 webrtc::StreamParams sp = CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2); 87 EXPECT_EQ(2U, sp.ssrcs.size()); 88 EXPECT_EQ(kSsrcs2[0], sp.first_ssrc()); 89 EXPECT_TRUE(sp.has_ssrcs()); 90 EXPECT_TRUE(sp.has_ssrc(kSsrcs2[0])); 91 EXPECT_TRUE(sp.has_ssrc(kSsrcs2[1])); 92 EXPECT_TRUE(sp.has_ssrc_group("XYZ")); 93 EXPECT_EQ(1U, sp.ssrc_groups.size()); 94 EXPECT_EQ(2U, sp.ssrc_groups[0].ssrcs.size()); 95 EXPECT_EQ(kSsrcs2[0], sp.ssrc_groups[0].ssrcs[0]); 96 EXPECT_EQ(kSsrcs2[1], sp.ssrc_groups[0].ssrcs[1]); 97 } 98 99 TEST(StreamParams, GetSsrcGroup) { 100 webrtc::StreamParams sp = CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2); 101 EXPECT_EQ(nullptr, sp.get_ssrc_group("xyz")); 102 EXPECT_EQ(&sp.ssrc_groups[0], sp.get_ssrc_group("XYZ")); 103 } 104 105 TEST(StreamParams, HasStreamWithNoSsrcs) { 106 webrtc::StreamParams sp_1 = webrtc::StreamParams::CreateLegacy(kSsrcs1[0]); 107 webrtc::StreamParams sp_2 = webrtc::StreamParams::CreateLegacy(kSsrcs2[0]); 108 std::vector<webrtc::StreamParams> streams({sp_1, sp_2}); 109 EXPECT_FALSE(webrtc::HasStreamWithNoSsrcs(streams)); 110 111 webrtc::StreamParams unsignaled_stream; 112 streams.push_back(unsignaled_stream); 113 EXPECT_TRUE(webrtc::HasStreamWithNoSsrcs(streams)); 114 } 115 116 TEST(StreamParams, EqualNotEqual) { 117 webrtc::StreamParams l1 = webrtc::StreamParams::CreateLegacy(1); 118 webrtc::StreamParams l2 = webrtc::StreamParams::CreateLegacy(2); 119 webrtc::StreamParams sg1 = CreateStreamParamsWithSsrcGroup("ABC", kSsrcs1); 120 webrtc::StreamParams sg2 = CreateStreamParamsWithSsrcGroup("ABC", kSsrcs2); 121 webrtc::StreamParams sg3 = CreateStreamParamsWithSsrcGroup("Abc", kSsrcs2); 122 webrtc::StreamParams sg4 = CreateStreamParamsWithSsrcGroup("abc", kSsrcs2); 123 webrtc::StreamParams sps[] = {l1, l2, sg1, sg2, sg3, sg4}; 124 125 for (size_t i = 0; i < std::size(sps); ++i) { 126 for (size_t j = 0; j < std::size(sps); ++j) { 127 EXPECT_EQ((sps[i] == sps[j]), (i == j)); 128 EXPECT_EQ((sps[i] != sps[j]), (i != j)); 129 } 130 } 131 } 132 133 TEST(StreamParams, FidFunctions) { 134 uint32_t fid_ssrc; 135 136 webrtc::StreamParams sp = webrtc::StreamParams::CreateLegacy(1); 137 EXPECT_FALSE(sp.AddFidSsrc(10, 20)); 138 EXPECT_TRUE(sp.AddFidSsrc(1, 2)); 139 EXPECT_TRUE(sp.GetFidSsrc(1, &fid_ssrc)); 140 EXPECT_EQ(2u, fid_ssrc); 141 EXPECT_FALSE(sp.GetFidSsrc(15, &fid_ssrc)); 142 143 sp.add_ssrc(20); 144 EXPECT_TRUE(sp.AddFidSsrc(20, 30)); 145 EXPECT_TRUE(sp.GetFidSsrc(20, &fid_ssrc)); 146 EXPECT_EQ(30u, fid_ssrc); 147 148 // Manually create SsrcGroup to test bounds-checking 149 // in GetSecondarySsrc. We construct an invalid StreamParams 150 // for this. 151 std::vector<uint32_t> fid_vector; 152 fid_vector.push_back(13); 153 webrtc::SsrcGroup invalid_fid_group(webrtc::kFidSsrcGroupSemantics, 154 fid_vector); 155 webrtc::StreamParams sp_invalid; 156 sp_invalid.add_ssrc(13); 157 sp_invalid.ssrc_groups.push_back(invalid_fid_group); 158 EXPECT_FALSE(sp_invalid.GetFidSsrc(13, &fid_ssrc)); 159 } 160 161 TEST(StreamParams, GetPrimaryAndFidSsrcs) { 162 webrtc::StreamParams sp; 163 sp.ssrcs.push_back(1); 164 sp.ssrcs.push_back(2); 165 sp.ssrcs.push_back(3); 166 167 std::vector<uint32_t> primary_ssrcs; 168 sp.GetPrimarySsrcs(&primary_ssrcs); 169 std::vector<uint32_t> fid_ssrcs; 170 sp.GetFidSsrcs(primary_ssrcs, &fid_ssrcs); 171 ASSERT_EQ(1u, primary_ssrcs.size()); 172 EXPECT_EQ(1u, primary_ssrcs[0]); 173 ASSERT_EQ(0u, fid_ssrcs.size()); 174 175 sp.ssrc_groups.push_back( 176 webrtc::SsrcGroup(webrtc::kSimSsrcGroupSemantics, sp.ssrcs)); 177 sp.AddFidSsrc(1, 10); 178 sp.AddFidSsrc(2, 20); 179 180 primary_ssrcs.clear(); 181 sp.GetPrimarySsrcs(&primary_ssrcs); 182 fid_ssrcs.clear(); 183 sp.GetFidSsrcs(primary_ssrcs, &fid_ssrcs); 184 ASSERT_EQ(3u, primary_ssrcs.size()); 185 EXPECT_EQ(1u, primary_ssrcs[0]); 186 EXPECT_EQ(2u, primary_ssrcs[1]); 187 EXPECT_EQ(3u, primary_ssrcs[2]); 188 ASSERT_EQ(2u, fid_ssrcs.size()); 189 EXPECT_EQ(10u, fid_ssrcs[0]); 190 EXPECT_EQ(20u, fid_ssrcs[1]); 191 } 192 193 TEST(StreamParams, FecFrFunctions) { 194 uint32_t fecfr_ssrc; 195 196 webrtc::StreamParams sp = webrtc::StreamParams::CreateLegacy(1); 197 EXPECT_FALSE(sp.AddFecFrSsrc(10, 20)); 198 EXPECT_TRUE(sp.AddFecFrSsrc(1, 2)); 199 EXPECT_TRUE(sp.GetFecFrSsrc(1, &fecfr_ssrc)); 200 EXPECT_EQ(2u, fecfr_ssrc); 201 EXPECT_FALSE(sp.GetFecFrSsrc(15, &fecfr_ssrc)); 202 203 sp.add_ssrc(20); 204 EXPECT_TRUE(sp.AddFecFrSsrc(20, 30)); 205 EXPECT_TRUE(sp.GetFecFrSsrc(20, &fecfr_ssrc)); 206 EXPECT_EQ(30u, fecfr_ssrc); 207 208 // Manually create SsrcGroup to test bounds-checking 209 // in GetSecondarySsrc. We construct an invalid StreamParams 210 // for this. 211 std::vector<uint32_t> fecfr_vector; 212 fecfr_vector.push_back(13); 213 webrtc::SsrcGroup invalid_fecfr_group(webrtc::kFecFrSsrcGroupSemantics, 214 fecfr_vector); 215 webrtc::StreamParams sp_invalid; 216 sp_invalid.add_ssrc(13); 217 sp_invalid.ssrc_groups.push_back(invalid_fecfr_group); 218 EXPECT_FALSE(sp_invalid.GetFecFrSsrc(13, &fecfr_ssrc)); 219 } 220 221 TEST(StreamParams, ToString) { 222 webrtc::StreamParams sp = CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2); 223 sp.set_stream_ids({"stream_id"}); 224 EXPECT_STREQ( 225 "{ssrcs:[1,2];ssrc_groups:{semantics:XYZ;ssrcs:[1,2]};stream_ids:stream_" 226 "id;}", 227 sp.ToString().c_str()); 228 } 229 230 TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithRtxAndFlex) { 231 webrtc::UniqueRandomIdGenerator generator; 232 webrtc::StreamParams stream; 233 stream.GenerateSsrcs(1, true, true, &generator); 234 uint32_t primary_ssrc = stream.first_ssrc(); 235 ASSERT_NE(0u, primary_ssrc); 236 uint32_t rtx_ssrc = 0; 237 uint32_t flex_ssrc = 0; 238 EXPECT_EQ(3u, stream.ssrcs.size()); 239 EXPECT_TRUE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); 240 EXPECT_NE(0u, rtx_ssrc); 241 EXPECT_TRUE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); 242 EXPECT_NE(0u, flex_ssrc); 243 EXPECT_FALSE(stream.has_ssrc_group(webrtc::kSimSsrcGroupSemantics)); 244 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kFidSsrcGroupSemantics)); 245 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kFecFrSsrcGroupSemantics)); 246 } 247 248 TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithRtx) { 249 webrtc::UniqueRandomIdGenerator generator; 250 webrtc::StreamParams stream; 251 stream.GenerateSsrcs(1, true, false, &generator); 252 uint32_t primary_ssrc = stream.first_ssrc(); 253 ASSERT_NE(0u, primary_ssrc); 254 uint32_t rtx_ssrc = 0; 255 uint32_t flex_ssrc = 0; 256 EXPECT_EQ(2u, stream.ssrcs.size()); 257 EXPECT_TRUE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); 258 EXPECT_NE(0u, rtx_ssrc); 259 EXPECT_FALSE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); 260 EXPECT_EQ(0u, flex_ssrc); 261 EXPECT_FALSE(stream.has_ssrc_group(webrtc::kSimSsrcGroupSemantics)); 262 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kFidSsrcGroupSemantics)); 263 } 264 265 TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithFlex) { 266 webrtc::UniqueRandomIdGenerator generator; 267 webrtc::StreamParams stream; 268 stream.GenerateSsrcs(1, false, true, &generator); 269 uint32_t primary_ssrc = stream.first_ssrc(); 270 ASSERT_NE(0u, primary_ssrc); 271 uint32_t rtx_ssrc = 0; 272 uint32_t flex_ssrc = 0; 273 EXPECT_EQ(2u, stream.ssrcs.size()); 274 EXPECT_FALSE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); 275 EXPECT_EQ(0u, rtx_ssrc); 276 EXPECT_TRUE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); 277 EXPECT_NE(0u, flex_ssrc); 278 EXPECT_FALSE(stream.has_ssrc_group(webrtc::kSimSsrcGroupSemantics)); 279 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kFecFrSsrcGroupSemantics)); 280 } 281 282 TEST(StreamParams, TestGenerateSsrcs_SimulcastLayersAndRtx) { 283 const size_t kNumStreams = 3; 284 webrtc::UniqueRandomIdGenerator generator; 285 webrtc::StreamParams stream; 286 stream.GenerateSsrcs(kNumStreams, true, false, &generator); 287 EXPECT_EQ(kNumStreams * 2, stream.ssrcs.size()); 288 std::vector<uint32_t> primary_ssrcs, rtx_ssrcs; 289 stream.GetPrimarySsrcs(&primary_ssrcs); 290 EXPECT_EQ(kNumStreams, primary_ssrcs.size()); 291 EXPECT_THAT(primary_ssrcs, Each(Ne(0u))); 292 stream.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs); 293 EXPECT_EQ(kNumStreams, rtx_ssrcs.size()); 294 EXPECT_THAT(rtx_ssrcs, Each(Ne(0u))); 295 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kSimSsrcGroupSemantics)); 296 EXPECT_TRUE(stream.has_ssrc_group(webrtc::kFidSsrcGroupSemantics)); 297 }