henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-08 04:46:45 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-08 04:46:45 | [diff] [blame] | 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. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 11 | #include "media/base/stream_params.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 12 | |
| 13 | #include <stdint.h> |
| 14 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 15 | #include "media/base/test_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 16 | #include "rtc_base/arraysize.h" |
Amit Hilbuch | bcd39d4 | 2019-01-26 01:13:56 | [diff] [blame] | 17 | #include "test/gmock.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 18 | #include "test/gtest.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 19 | |
Amit Hilbuch | bcd39d4 | 2019-01-26 01:13:56 | [diff] [blame] | 20 | using ::testing::Each; |
| 21 | using ::testing::Ne; |
| 22 | |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 23 | static const uint32_t kSsrcs1[] = {1}; |
| 24 | static const uint32_t kSsrcs2[] = {1, 2}; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 25 | |
| 26 | static cricket::StreamParams CreateStreamParamsWithSsrcGroup( |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 27 | const std::string& semantics, |
| 28 | const uint32_t ssrcs_in[], |
| 29 | size_t len) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 30 | cricket::StreamParams stream; |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 31 | std::vector<uint32_t> ssrcs(ssrcs_in, ssrcs_in + len); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 32 | cricket::SsrcGroup sg(semantics, ssrcs); |
| 33 | stream.ssrcs = ssrcs; |
| 34 | stream.ssrc_groups.push_back(sg); |
| 35 | return stream; |
| 36 | } |
| 37 | |
| 38 | TEST(SsrcGroup, EqualNotEqual) { |
| 39 | cricket::SsrcGroup ssrc_groups[] = { |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 40 | cricket::SsrcGroup("ABC", MAKE_VECTOR(kSsrcs1)), |
| 41 | cricket::SsrcGroup("ABC", MAKE_VECTOR(kSsrcs2)), |
| 42 | cricket::SsrcGroup("Abc", MAKE_VECTOR(kSsrcs2)), |
| 43 | cricket::SsrcGroup("abc", MAKE_VECTOR(kSsrcs2)), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 44 | }; |
| 45 | |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 46 | for (size_t i = 0; i < arraysize(ssrc_groups); ++i) { |
| 47 | for (size_t j = 0; j < arraysize(ssrc_groups); ++j) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 48 | EXPECT_EQ((ssrc_groups[i] == ssrc_groups[j]), (i == j)); |
| 49 | EXPECT_EQ((ssrc_groups[i] != ssrc_groups[j]), (i != j)); |
| 50 | } |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | TEST(SsrcGroup, HasSemantics) { |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 55 | cricket::SsrcGroup sg1("ABC", MAKE_VECTOR(kSsrcs1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 56 | EXPECT_TRUE(sg1.has_semantics("ABC")); |
| 57 | |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 58 | cricket::SsrcGroup sg2("Abc", MAKE_VECTOR(kSsrcs1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 59 | EXPECT_FALSE(sg2.has_semantics("ABC")); |
| 60 | |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 61 | cricket::SsrcGroup sg3("abc", MAKE_VECTOR(kSsrcs1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 62 | EXPECT_FALSE(sg3.has_semantics("ABC")); |
| 63 | } |
| 64 | |
| 65 | TEST(SsrcGroup, ToString) { |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 66 | cricket::SsrcGroup sg1("ABC", MAKE_VECTOR(kSsrcs1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 67 | EXPECT_STREQ("{semantics:ABC;ssrcs:[1]}", sg1.ToString().c_str()); |
| 68 | } |
| 69 | |
| 70 | TEST(StreamParams, CreateLegacy) { |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 71 | const uint32_t ssrc = 7; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 72 | cricket::StreamParams one_sp = cricket::StreamParams::CreateLegacy(ssrc); |
| 73 | EXPECT_EQ(1U, one_sp.ssrcs.size()); |
| 74 | EXPECT_EQ(ssrc, one_sp.first_ssrc()); |
| 75 | EXPECT_TRUE(one_sp.has_ssrcs()); |
| 76 | EXPECT_TRUE(one_sp.has_ssrc(ssrc)); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 77 | EXPECT_FALSE(one_sp.has_ssrc(ssrc + 1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 78 | EXPECT_FALSE(one_sp.has_ssrc_groups()); |
| 79 | EXPECT_EQ(0U, one_sp.ssrc_groups.size()); |
| 80 | } |
| 81 | |
| 82 | TEST(StreamParams, HasSsrcGroup) { |
| 83 | cricket::StreamParams sp = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 84 | CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2, arraysize(kSsrcs2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 85 | EXPECT_EQ(2U, sp.ssrcs.size()); |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 86 | EXPECT_EQ(kSsrcs2[0], sp.first_ssrc()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 87 | EXPECT_TRUE(sp.has_ssrcs()); |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 88 | EXPECT_TRUE(sp.has_ssrc(kSsrcs2[0])); |
| 89 | EXPECT_TRUE(sp.has_ssrc(kSsrcs2[1])); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 90 | EXPECT_TRUE(sp.has_ssrc_group("XYZ")); |
| 91 | EXPECT_EQ(1U, sp.ssrc_groups.size()); |
| 92 | EXPECT_EQ(2U, sp.ssrc_groups[0].ssrcs.size()); |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 93 | EXPECT_EQ(kSsrcs2[0], sp.ssrc_groups[0].ssrcs[0]); |
| 94 | EXPECT_EQ(kSsrcs2[1], sp.ssrc_groups[0].ssrcs[1]); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | TEST(StreamParams, GetSsrcGroup) { |
| 98 | cricket::StreamParams sp = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 99 | CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2, arraysize(kSsrcs2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 100 | EXPECT_EQ(NULL, sp.get_ssrc_group("xyz")); |
| 101 | EXPECT_EQ(&sp.ssrc_groups[0], sp.get_ssrc_group("XYZ")); |
| 102 | } |
| 103 | |
Seth Hampson | 5897a6e | 2018-04-03 18:16:33 | [diff] [blame] | 104 | TEST(StreamParams, HasStreamWithNoSsrcs) { |
| 105 | cricket::StreamParams sp_1 = cricket::StreamParams::CreateLegacy(kSsrcs1[0]); |
| 106 | cricket::StreamParams sp_2 = cricket::StreamParams::CreateLegacy(kSsrcs2[0]); |
| 107 | std::vector<cricket::StreamParams> streams({sp_1, sp_2}); |
| 108 | EXPECT_FALSE(HasStreamWithNoSsrcs(streams)); |
| 109 | |
| 110 | cricket::StreamParams unsignaled_stream; |
| 111 | streams.push_back(unsignaled_stream); |
| 112 | EXPECT_TRUE(HasStreamWithNoSsrcs(streams)); |
| 113 | } |
| 114 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 115 | TEST(StreamParams, EqualNotEqual) { |
| 116 | cricket::StreamParams l1 = cricket::StreamParams::CreateLegacy(1); |
| 117 | cricket::StreamParams l2 = cricket::StreamParams::CreateLegacy(2); |
| 118 | cricket::StreamParams sg1 = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 119 | CreateStreamParamsWithSsrcGroup("ABC", kSsrcs1, arraysize(kSsrcs1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 120 | cricket::StreamParams sg2 = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 121 | CreateStreamParamsWithSsrcGroup("ABC", kSsrcs2, arraysize(kSsrcs2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 122 | cricket::StreamParams sg3 = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 123 | CreateStreamParamsWithSsrcGroup("Abc", kSsrcs2, arraysize(kSsrcs2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 124 | cricket::StreamParams sg4 = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 125 | CreateStreamParamsWithSsrcGroup("abc", kSsrcs2, arraysize(kSsrcs2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 126 | cricket::StreamParams sps[] = {l1, l2, sg1, sg2, sg3, sg4}; |
| 127 | |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 128 | for (size_t i = 0; i < arraysize(sps); ++i) { |
| 129 | for (size_t j = 0; j < arraysize(sps); ++j) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 130 | EXPECT_EQ((sps[i] == sps[j]), (i == j)); |
| 131 | EXPECT_EQ((sps[i] != sps[j]), (i != j)); |
| 132 | } |
| 133 | } |
| 134 | } |
| 135 | |
| 136 | TEST(StreamParams, FidFunctions) { |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 137 | uint32_t fid_ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 138 | |
| 139 | cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(1); |
| 140 | EXPECT_FALSE(sp.AddFidSsrc(10, 20)); |
| 141 | EXPECT_TRUE(sp.AddFidSsrc(1, 2)); |
| 142 | EXPECT_TRUE(sp.GetFidSsrc(1, &fid_ssrc)); |
| 143 | EXPECT_EQ(2u, fid_ssrc); |
| 144 | EXPECT_FALSE(sp.GetFidSsrc(15, &fid_ssrc)); |
| 145 | |
| 146 | sp.add_ssrc(20); |
brandtr | 9688e38 | 2016-11-22 08:59:48 | [diff] [blame] | 147 | EXPECT_TRUE(sp.AddFidSsrc(20, 30)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 148 | EXPECT_TRUE(sp.GetFidSsrc(20, &fid_ssrc)); |
| 149 | EXPECT_EQ(30u, fid_ssrc); |
| 150 | |
| 151 | // Manually create SsrcGroup to test bounds-checking |
| 152 | // in GetSecondarySsrc. We construct an invalid StreamParams |
| 153 | // for this. |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 154 | std::vector<uint32_t> fid_vector; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 155 | fid_vector.push_back(13); |
| 156 | cricket::SsrcGroup invalid_fid_group(cricket::kFidSsrcGroupSemantics, |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 157 | fid_vector); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 158 | cricket::StreamParams sp_invalid; |
| 159 | sp_invalid.add_ssrc(13); |
| 160 | sp_invalid.ssrc_groups.push_back(invalid_fid_group); |
| 161 | EXPECT_FALSE(sp_invalid.GetFidSsrc(13, &fid_ssrc)); |
| 162 | } |
| 163 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 | [diff] [blame] | 164 | TEST(StreamParams, GetPrimaryAndFidSsrcs) { |
| 165 | cricket::StreamParams sp; |
| 166 | sp.ssrcs.push_back(1); |
| 167 | sp.ssrcs.push_back(2); |
| 168 | sp.ssrcs.push_back(3); |
| 169 | |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 170 | std::vector<uint32_t> primary_ssrcs; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 | [diff] [blame] | 171 | sp.GetPrimarySsrcs(&primary_ssrcs); |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 172 | std::vector<uint32_t> fid_ssrcs; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 | [diff] [blame] | 173 | sp.GetFidSsrcs(primary_ssrcs, &fid_ssrcs); |
| 174 | ASSERT_EQ(1u, primary_ssrcs.size()); |
| 175 | EXPECT_EQ(1u, primary_ssrcs[0]); |
| 176 | ASSERT_EQ(0u, fid_ssrcs.size()); |
| 177 | |
| 178 | sp.ssrc_groups.push_back( |
| 179 | cricket::SsrcGroup(cricket::kSimSsrcGroupSemantics, sp.ssrcs)); |
| 180 | sp.AddFidSsrc(1, 10); |
| 181 | sp.AddFidSsrc(2, 20); |
| 182 | |
| 183 | primary_ssrcs.clear(); |
| 184 | sp.GetPrimarySsrcs(&primary_ssrcs); |
| 185 | fid_ssrcs.clear(); |
| 186 | sp.GetFidSsrcs(primary_ssrcs, &fid_ssrcs); |
| 187 | ASSERT_EQ(3u, primary_ssrcs.size()); |
| 188 | EXPECT_EQ(1u, primary_ssrcs[0]); |
| 189 | EXPECT_EQ(2u, primary_ssrcs[1]); |
| 190 | EXPECT_EQ(3u, primary_ssrcs[2]); |
| 191 | ASSERT_EQ(2u, fid_ssrcs.size()); |
| 192 | EXPECT_EQ(10u, fid_ssrcs[0]); |
| 193 | EXPECT_EQ(20u, fid_ssrcs[1]); |
| 194 | } |
| 195 | |
brandtr | 9688e38 | 2016-11-22 08:59:48 | [diff] [blame] | 196 | TEST(StreamParams, FecFrFunctions) { |
| 197 | uint32_t fecfr_ssrc; |
| 198 | |
| 199 | cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(1); |
| 200 | EXPECT_FALSE(sp.AddFecFrSsrc(10, 20)); |
| 201 | EXPECT_TRUE(sp.AddFecFrSsrc(1, 2)); |
| 202 | EXPECT_TRUE(sp.GetFecFrSsrc(1, &fecfr_ssrc)); |
| 203 | EXPECT_EQ(2u, fecfr_ssrc); |
| 204 | EXPECT_FALSE(sp.GetFecFrSsrc(15, &fecfr_ssrc)); |
| 205 | |
| 206 | sp.add_ssrc(20); |
| 207 | EXPECT_TRUE(sp.AddFecFrSsrc(20, 30)); |
| 208 | EXPECT_TRUE(sp.GetFecFrSsrc(20, &fecfr_ssrc)); |
| 209 | EXPECT_EQ(30u, fecfr_ssrc); |
| 210 | |
| 211 | // Manually create SsrcGroup to test bounds-checking |
| 212 | // in GetSecondarySsrc. We construct an invalid StreamParams |
| 213 | // for this. |
| 214 | std::vector<uint32_t> fecfr_vector; |
| 215 | fecfr_vector.push_back(13); |
| 216 | cricket::SsrcGroup invalid_fecfr_group(cricket::kFecFrSsrcGroupSemantics, |
| 217 | fecfr_vector); |
| 218 | cricket::StreamParams sp_invalid; |
| 219 | sp_invalid.add_ssrc(13); |
| 220 | sp_invalid.ssrc_groups.push_back(invalid_fecfr_group); |
| 221 | EXPECT_FALSE(sp_invalid.GetFecFrSsrc(13, &fecfr_ssrc)); |
| 222 | } |
| 223 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 224 | TEST(StreamParams, ToString) { |
| 225 | cricket::StreamParams sp = |
tfarina | 5237aaf | 2015-11-11 07:44:30 | [diff] [blame] | 226 | CreateStreamParamsWithSsrcGroup("XYZ", kSsrcs2, arraysize(kSsrcs2)); |
Seth Hampson | 5b4f075 | 2018-04-02 23:31:36 | [diff] [blame] | 227 | sp.set_stream_ids({"stream_id"}); |
| 228 | EXPECT_STREQ( |
| 229 | "{ssrcs:[1,2];ssrc_groups:{semantics:XYZ;ssrcs:[1,2]};stream_ids:stream_" |
| 230 | "id;}", |
| 231 | sp.ToString().c_str()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 232 | } |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 233 | |
Amit Hilbuch | bcd39d4 | 2019-01-26 01:13:56 | [diff] [blame] | 234 | TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithRtxAndFlex) { |
| 235 | rtc::UniqueRandomIdGenerator generator; |
| 236 | cricket::StreamParams stream; |
| 237 | stream.GenerateSsrcs(1, true, true, &generator); |
| 238 | uint32_t primary_ssrc = stream.first_ssrc(); |
| 239 | ASSERT_NE(0u, primary_ssrc); |
| 240 | uint32_t rtx_ssrc = 0; |
| 241 | uint32_t flex_ssrc = 0; |
| 242 | EXPECT_EQ(3u, stream.ssrcs.size()); |
| 243 | EXPECT_TRUE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); |
| 244 | EXPECT_NE(0u, rtx_ssrc); |
| 245 | EXPECT_TRUE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); |
| 246 | EXPECT_NE(0u, flex_ssrc); |
| 247 | EXPECT_FALSE(stream.has_ssrc_group(cricket::kSimSsrcGroupSemantics)); |
| 248 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kFidSsrcGroupSemantics)); |
| 249 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kFecFrSsrcGroupSemantics)); |
| 250 | } |
| 251 | |
| 252 | TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithRtx) { |
| 253 | rtc::UniqueRandomIdGenerator generator; |
| 254 | cricket::StreamParams stream; |
| 255 | stream.GenerateSsrcs(1, true, false, &generator); |
| 256 | uint32_t primary_ssrc = stream.first_ssrc(); |
| 257 | ASSERT_NE(0u, primary_ssrc); |
| 258 | uint32_t rtx_ssrc = 0; |
| 259 | uint32_t flex_ssrc = 0; |
| 260 | EXPECT_EQ(2u, stream.ssrcs.size()); |
| 261 | EXPECT_TRUE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); |
| 262 | EXPECT_NE(0u, rtx_ssrc); |
| 263 | EXPECT_FALSE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); |
| 264 | EXPECT_EQ(0u, flex_ssrc); |
| 265 | EXPECT_FALSE(stream.has_ssrc_group(cricket::kSimSsrcGroupSemantics)); |
| 266 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kFidSsrcGroupSemantics)); |
| 267 | } |
| 268 | |
| 269 | TEST(StreamParams, TestGenerateSsrcs_SingleStreamWithFlex) { |
| 270 | rtc::UniqueRandomIdGenerator generator; |
| 271 | cricket::StreamParams stream; |
| 272 | stream.GenerateSsrcs(1, false, true, &generator); |
| 273 | uint32_t primary_ssrc = stream.first_ssrc(); |
| 274 | ASSERT_NE(0u, primary_ssrc); |
| 275 | uint32_t rtx_ssrc = 0; |
| 276 | uint32_t flex_ssrc = 0; |
| 277 | EXPECT_EQ(2u, stream.ssrcs.size()); |
| 278 | EXPECT_FALSE(stream.GetFidSsrc(primary_ssrc, &rtx_ssrc)); |
| 279 | EXPECT_EQ(0u, rtx_ssrc); |
| 280 | EXPECT_TRUE(stream.GetFecFrSsrc(primary_ssrc, &flex_ssrc)); |
| 281 | EXPECT_NE(0u, flex_ssrc); |
| 282 | EXPECT_FALSE(stream.has_ssrc_group(cricket::kSimSsrcGroupSemantics)); |
| 283 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kFecFrSsrcGroupSemantics)); |
| 284 | } |
| 285 | |
| 286 | TEST(StreamParams, TestGenerateSsrcs_SimulcastLayersAndRtx) { |
| 287 | const size_t kNumStreams = 3; |
| 288 | rtc::UniqueRandomIdGenerator generator; |
| 289 | cricket::StreamParams stream; |
| 290 | stream.GenerateSsrcs(kNumStreams, true, false, &generator); |
| 291 | EXPECT_EQ(kNumStreams * 2, stream.ssrcs.size()); |
| 292 | std::vector<uint32_t> primary_ssrcs, rtx_ssrcs; |
| 293 | stream.GetPrimarySsrcs(&primary_ssrcs); |
| 294 | EXPECT_EQ(kNumStreams, primary_ssrcs.size()); |
| 295 | EXPECT_THAT(primary_ssrcs, Each(Ne(0u))); |
| 296 | stream.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs); |
| 297 | EXPECT_EQ(kNumStreams, rtx_ssrcs.size()); |
| 298 | EXPECT_THAT(rtx_ssrcs, Each(Ne(0u))); |
| 299 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kSimSsrcGroupSemantics)); |
| 300 | EXPECT_TRUE(stream.has_ssrc_group(cricket::kFidSsrcGroupSemantics)); |
| 301 | } |