OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 | 12 |
13 #include "webrtc/common_types.h" | 13 #include "webrtc/common_types.h" |
14 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" | 14 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
15 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h" | 15 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h" |
16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
| 17 #include "webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h" |
17 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" | 18 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" |
18 #include "webrtc/test/gmock.h" | 19 #include "webrtc/test/gmock.h" |
19 #include "webrtc/test/gtest.h" | 20 #include "webrtc/test/gtest.h" |
20 | 21 |
21 namespace webrtc { | 22 namespace webrtc { |
22 | 23 |
23 using ::testing::Eq; | 24 using ::testing::Eq; |
24 using ::testing::Return; | 25 using ::testing::Return; |
25 using ::testing::StrEq; | 26 using ::testing::StrEq; |
26 using ::testing::_; | 27 using ::testing::_; |
27 | 28 |
28 static const char* kTypicalPayloadName = "name"; | 29 static const char* kTypicalPayloadName = "name"; |
29 static const size_t kTypicalChannels = 1; | 30 static const size_t kTypicalChannels = 1; |
30 static const uint32_t kTypicalFrequency = 44000; | 31 static const int kTypicalFrequency = 44000; |
31 static const uint32_t kTypicalRate = 32 * 1024; | 32 static const int kTypicalRate = 32 * 1024; |
32 static const CodecInst kTypicalAudioCodec = {-1 /* pltype */, "name", | 33 static const CodecInst kTypicalAudioCodec = {-1 /* pltype */, "name", |
33 kTypicalFrequency, 0 /* pacsize */, | 34 kTypicalFrequency, 0 /* pacsize */, |
34 kTypicalChannels, kTypicalRate}; | 35 kTypicalChannels, kTypicalRate}; |
35 | 36 |
36 TEST(RtpPayloadRegistryTest, | 37 class RtpPayloadRegistryTest : public ::testing::Test { |
37 RegistersAndRemembersVideoPayloadsUntilDeregistered) { | 38 public: |
38 RTPPayloadRegistry rtp_payload_registry; | 39 void SetUp() { |
| 40 // Note: the payload registry takes ownership of the strategy. |
| 41 mock_payload_strategy_ = new testing::NiceMock<MockRTPPayloadStrategy>(); |
| 42 rtp_payload_registry_.reset(new RTPPayloadRegistry(mock_payload_strategy_)); |
| 43 } |
| 44 |
| 45 protected: |
| 46 RtpUtility::Payload* ExpectReturnOfTypicalAudioPayload(uint8_t payload_type, |
| 47 uint32_t rate) { |
| 48 bool audio = true; |
| 49 RtpUtility::Payload returned_payload = { |
| 50 "name", |
| 51 audio, |
| 52 {// Initialize the audio struct in this case. |
| 53 {kTypicalFrequency, kTypicalChannels, rate}}}; |
| 54 |
| 55 // Note: we return a new payload since the payload registry takes ownership |
| 56 // of the created object. |
| 57 RtpUtility::Payload* returned_payload_on_heap = |
| 58 new RtpUtility::Payload(returned_payload); |
| 59 EXPECT_CALL(*mock_payload_strategy_, |
| 60 CreatePayloadType(StrEq(kTypicalPayloadName), payload_type, |
| 61 kTypicalFrequency, kTypicalChannels, rate)) |
| 62 .WillOnce(Return(returned_payload_on_heap)); |
| 63 return returned_payload_on_heap; |
| 64 } |
| 65 |
| 66 std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_; |
| 67 testing::NiceMock<MockRTPPayloadStrategy>* mock_payload_strategy_; |
| 68 }; |
| 69 |
| 70 TEST_F(RtpPayloadRegistryTest, |
| 71 RegistersAndRemembersVideoPayloadsUntilDeregistered) { |
39 const uint8_t payload_type = 97; | 72 const uint8_t payload_type = 97; |
| 73 RtpUtility::Payload returned_video_payload = { |
| 74 "VP8", false /* audio */, {{kRtpVideoVp8}}}; |
| 75 // Note: The payload registry takes ownership of this object in |
| 76 // RegisterReceivePayload. |
| 77 RtpUtility::Payload* returned_video_payload_on_heap = |
| 78 new RtpUtility::Payload(returned_video_payload); |
| 79 EXPECT_CALL( |
| 80 *mock_payload_strategy_, |
| 81 CreatePayloadType(StrEq("VP8"), payload_type, kVideoPayloadTypeFrequency, |
| 82 0 /* channels */, 0 /* rate */)) |
| 83 .WillOnce(Return(returned_video_payload_on_heap)); |
| 84 |
40 VideoCodec video_codec; | 85 VideoCodec video_codec; |
41 video_codec.codecType = kVideoCodecVP8; | 86 video_codec.codecType = kVideoCodecVP8; |
42 strncpy(video_codec.plName, "VP8", RTP_PAYLOAD_NAME_SIZE); | 87 strncpy(video_codec.plName, "VP8", RTP_PAYLOAD_NAME_SIZE); |
43 video_codec.plType = payload_type; | 88 video_codec.plType = payload_type; |
44 | 89 |
45 EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload(video_codec)); | 90 EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(video_codec)); |
46 | 91 |
47 const RtpUtility::Payload* retrieved_payload = | 92 const RtpUtility::Payload* retrieved_payload = |
48 rtp_payload_registry.PayloadTypeToPayload(payload_type); | 93 rtp_payload_registry_->PayloadTypeToPayload(payload_type); |
49 EXPECT_TRUE(retrieved_payload); | 94 EXPECT_TRUE(retrieved_payload); |
50 | 95 |
51 // We should get back the corresponding payload that we registered. | 96 // We should get back the exact pointer to the payload returned by the |
52 EXPECT_STREQ("VP8", retrieved_payload->name); | 97 // payload strategy. |
53 EXPECT_FALSE(retrieved_payload->audio); | 98 EXPECT_EQ(returned_video_payload_on_heap, retrieved_payload); |
54 EXPECT_EQ(kRtpVideoVp8, retrieved_payload->typeSpecific.Video.videoCodecType); | |
55 | 99 |
56 // Now forget about it and verify it's gone. | 100 // Now forget about it and verify it's gone. |
57 EXPECT_EQ(0, rtp_payload_registry.DeRegisterReceivePayload(payload_type)); | 101 EXPECT_EQ(0, rtp_payload_registry_->DeRegisterReceivePayload(payload_type)); |
58 EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type)); | 102 EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(payload_type)); |
59 } | 103 } |
60 | 104 |
61 TEST(RtpPayloadRegistryTest, | 105 TEST_F(RtpPayloadRegistryTest, |
62 RegistersAndRemembersAudioPayloadsUntilDeregistered) { | 106 RegistersAndRemembersAudioPayloadsUntilDeregistered) { |
63 RTPPayloadRegistry rtp_payload_registry; | |
64 uint8_t payload_type = 97; | 107 uint8_t payload_type = 97; |
| 108 RtpUtility::Payload* returned_payload_on_heap = |
| 109 ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate); |
| 110 |
65 bool new_payload_created = false; | 111 bool new_payload_created = false; |
66 CodecInst audio_codec = kTypicalAudioCodec; | 112 CodecInst audio_codec = kTypicalAudioCodec; |
67 audio_codec.pltype = payload_type; | 113 audio_codec.pltype = payload_type; |
68 EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload( | 114 EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload( |
69 audio_codec, &new_payload_created)); | 115 audio_codec, &new_payload_created)); |
70 | 116 |
71 EXPECT_TRUE(new_payload_created) << "A new payload WAS created."; | 117 EXPECT_TRUE(new_payload_created) << "A new payload WAS created."; |
72 | 118 |
73 const RtpUtility::Payload* retrieved_payload = | 119 const RtpUtility::Payload* retrieved_payload = |
74 rtp_payload_registry.PayloadTypeToPayload(payload_type); | 120 rtp_payload_registry_->PayloadTypeToPayload(payload_type); |
75 EXPECT_TRUE(retrieved_payload); | 121 EXPECT_TRUE(retrieved_payload); |
76 | 122 |
77 // We should get back the corresponding payload that we registered. | 123 // We should get back the exact pointer to the payload returned by the |
78 EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name); | 124 // payload strategy. |
79 EXPECT_TRUE(retrieved_payload->audio); | 125 EXPECT_EQ(returned_payload_on_heap, retrieved_payload); |
80 EXPECT_EQ(kTypicalFrequency, retrieved_payload->typeSpecific.Audio.frequency); | |
81 EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels); | |
82 EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate); | |
83 | 126 |
84 // Now forget about it and verify it's gone. | 127 // Now forget about it and verify it's gone. |
85 EXPECT_EQ(0, rtp_payload_registry.DeRegisterReceivePayload(payload_type)); | 128 EXPECT_EQ(0, rtp_payload_registry_->DeRegisterReceivePayload(payload_type)); |
86 EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type)); | 129 EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(payload_type)); |
87 } | 130 } |
88 | 131 |
89 TEST(RtpPayloadRegistryTest, AudioRedWorkProperly) { | 132 TEST_F(RtpPayloadRegistryTest, AudioRedWorkProperly) { |
90 const uint8_t kRedPayloadType = 127; | 133 const uint8_t kRedPayloadType = 127; |
91 const int kRedSampleRate = 8000; | 134 const int kRedSampleRate = 8000; |
92 const size_t kRedChannels = 1; | 135 const size_t kRedChannels = 1; |
93 const int kRedBitRate = 0; | 136 const int kRedBitRate = 0; |
94 | 137 |
95 RTPPayloadRegistry rtp_payload_registry; | 138 // This creates an audio RTP payload strategy. |
| 139 rtp_payload_registry_.reset( |
| 140 new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(true))); |
96 | 141 |
97 bool new_payload_created = false; | 142 bool new_payload_created = false; |
98 CodecInst red_audio_codec; | 143 CodecInst red_audio_codec; |
99 strncpy(red_audio_codec.plname, "red", RTP_PAYLOAD_NAME_SIZE); | 144 strncpy(red_audio_codec.plname, "red", RTP_PAYLOAD_NAME_SIZE); |
100 red_audio_codec.pltype = kRedPayloadType; | 145 red_audio_codec.pltype = kRedPayloadType; |
101 red_audio_codec.plfreq = kRedSampleRate; | 146 red_audio_codec.plfreq = kRedSampleRate; |
102 red_audio_codec.channels = kRedChannels; | 147 red_audio_codec.channels = kRedChannels; |
103 red_audio_codec.rate = kRedBitRate; | 148 red_audio_codec.rate = kRedBitRate; |
104 EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload( | 149 EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload( |
105 red_audio_codec, &new_payload_created)); | 150 red_audio_codec, &new_payload_created)); |
106 EXPECT_TRUE(new_payload_created); | 151 EXPECT_TRUE(new_payload_created); |
107 | 152 |
108 EXPECT_EQ(kRedPayloadType, rtp_payload_registry.red_payload_type()); | 153 EXPECT_EQ(kRedPayloadType, rtp_payload_registry_->red_payload_type()); |
109 | 154 |
110 const RtpUtility::Payload* retrieved_payload = | 155 const RtpUtility::Payload* retrieved_payload = |
111 rtp_payload_registry.PayloadTypeToPayload(kRedPayloadType); | 156 rtp_payload_registry_->PayloadTypeToPayload(kRedPayloadType); |
112 EXPECT_TRUE(retrieved_payload); | 157 EXPECT_TRUE(retrieved_payload); |
113 EXPECT_TRUE(retrieved_payload->audio); | 158 EXPECT_TRUE(retrieved_payload->audio); |
114 EXPECT_STRCASEEQ("red", retrieved_payload->name); | 159 EXPECT_STRCASEEQ("red", retrieved_payload->name); |
115 | 160 |
116 // Sample rate is correctly registered. | 161 // Sample rate is correctly registered. |
117 EXPECT_EQ(kRedSampleRate, | 162 EXPECT_EQ(kRedSampleRate, |
118 rtp_payload_registry.GetPayloadTypeFrequency(kRedPayloadType)); | 163 rtp_payload_registry_->GetPayloadTypeFrequency(kRedPayloadType)); |
119 } | 164 } |
120 | 165 |
121 TEST(RtpPayloadRegistryTest, | 166 TEST_F(RtpPayloadRegistryTest, |
122 DoesNotAcceptSamePayloadTypeTwiceExceptIfPayloadIsCompatible) { | 167 DoesNotAcceptSamePayloadTypeTwiceExceptIfPayloadIsCompatible) { |
123 uint8_t payload_type = 97; | 168 uint8_t payload_type = 97; |
124 RTPPayloadRegistry rtp_payload_registry; | |
125 | 169 |
126 bool ignored = false; | 170 bool ignored = false; |
| 171 RtpUtility::Payload* first_payload_on_heap = |
| 172 ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate); |
127 CodecInst audio_codec = kTypicalAudioCodec; | 173 CodecInst audio_codec = kTypicalAudioCodec; |
128 audio_codec.pltype = payload_type; | 174 audio_codec.pltype = payload_type; |
129 EXPECT_EQ(0, | 175 EXPECT_EQ( |
130 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 176 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
131 | 177 |
| 178 EXPECT_EQ( |
| 179 -1, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)) |
| 180 << "Adding same codec twice = bad."; |
| 181 |
| 182 RtpUtility::Payload* second_payload_on_heap = |
| 183 ExpectReturnOfTypicalAudioPayload(payload_type - 1, kTypicalRate); |
132 CodecInst audio_codec_2 = kTypicalAudioCodec; | 184 CodecInst audio_codec_2 = kTypicalAudioCodec; |
133 audio_codec_2.pltype = payload_type; | |
134 // Make |audio_codec_2| incompatible with |audio_codec| by changing | |
135 // the frequency. | |
136 audio_codec_2.plfreq = kTypicalFrequency + 1; | |
137 EXPECT_EQ( | |
138 -1, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored)) | |
139 << "Adding incompatible codec with same payload type = bad."; | |
140 | |
141 // Change payload type. | |
142 audio_codec_2.pltype = payload_type - 1; | 185 audio_codec_2.pltype = payload_type - 1; |
143 EXPECT_EQ( | 186 EXPECT_EQ( |
144 0, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored)) | 187 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec_2, &ignored)) |
145 << "With a different payload type is fine though."; | 188 << "With a different payload type is fine though."; |
146 | 189 |
147 // Ensure both payloads are preserved. | 190 // Ensure both payloads are preserved. |
148 const RtpUtility::Payload* retrieved_payload = | 191 const RtpUtility::Payload* retrieved_payload = |
149 rtp_payload_registry.PayloadTypeToPayload(payload_type); | 192 rtp_payload_registry_->PayloadTypeToPayload(payload_type); |
150 EXPECT_TRUE(retrieved_payload); | 193 EXPECT_TRUE(retrieved_payload); |
151 EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name); | 194 EXPECT_EQ(first_payload_on_heap, retrieved_payload); |
152 EXPECT_TRUE(retrieved_payload->audio); | |
153 EXPECT_EQ(kTypicalFrequency, retrieved_payload->typeSpecific.Audio.frequency); | |
154 EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels); | |
155 EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate); | |
156 | |
157 retrieved_payload = | 195 retrieved_payload = |
158 rtp_payload_registry.PayloadTypeToPayload(payload_type - 1); | 196 rtp_payload_registry_->PayloadTypeToPayload(payload_type - 1); |
159 EXPECT_TRUE(retrieved_payload); | 197 EXPECT_TRUE(retrieved_payload); |
160 EXPECT_STREQ(kTypicalPayloadName, retrieved_payload->name); | 198 EXPECT_EQ(second_payload_on_heap, retrieved_payload); |
161 EXPECT_TRUE(retrieved_payload->audio); | |
162 EXPECT_EQ(kTypicalFrequency + 1, | |
163 retrieved_payload->typeSpecific.Audio.frequency); | |
164 EXPECT_EQ(kTypicalChannels, retrieved_payload->typeSpecific.Audio.channels); | |
165 EXPECT_EQ(kTypicalRate, retrieved_payload->typeSpecific.Audio.rate); | |
166 | 199 |
167 // Ok, update the rate for one of the codecs. If either the incoming rate or | 200 // Ok, update the rate for one of the codecs. If either the incoming rate or |
168 // the stored rate is zero it's not really an error to register the same | 201 // the stored rate is zero it's not really an error to register the same |
169 // codec twice, and in that case roughly the following happens. | 202 // codec twice, and in that case roughly the following happens. |
170 EXPECT_EQ(0, | 203 ON_CALL(*mock_payload_strategy_, PayloadIsCompatible(_, _, _, _)) |
171 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 204 .WillByDefault(Return(true)); |
| 205 EXPECT_CALL(*mock_payload_strategy_, |
| 206 UpdatePayloadRate(first_payload_on_heap, kTypicalRate)); |
| 207 EXPECT_EQ( |
| 208 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
172 } | 209 } |
173 | 210 |
174 TEST(RtpPayloadRegistryTest, | 211 TEST_F(RtpPayloadRegistryTest, |
175 RemovesCompatibleCodecsOnRegistryIfCodecsMustBeUnique) { | 212 RemovesCompatibleCodecsOnRegistryIfCodecsMustBeUnique) { |
| 213 ON_CALL(*mock_payload_strategy_, PayloadIsCompatible(_, _, _, _)) |
| 214 .WillByDefault(Return(true)); |
| 215 ON_CALL(*mock_payload_strategy_, CodecsMustBeUnique()) |
| 216 .WillByDefault(Return(true)); |
| 217 |
176 uint8_t payload_type = 97; | 218 uint8_t payload_type = 97; |
177 RTPPayloadRegistry rtp_payload_registry; | |
178 | 219 |
179 bool ignored = false; | 220 bool ignored = false; |
| 221 ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate); |
180 CodecInst audio_codec = kTypicalAudioCodec; | 222 CodecInst audio_codec = kTypicalAudioCodec; |
181 audio_codec.pltype = payload_type; | 223 audio_codec.pltype = payload_type; |
182 EXPECT_EQ(0, | 224 EXPECT_EQ( |
183 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 225 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
| 226 ExpectReturnOfTypicalAudioPayload(payload_type - 1, kTypicalRate); |
184 CodecInst audio_codec_2 = kTypicalAudioCodec; | 227 CodecInst audio_codec_2 = kTypicalAudioCodec; |
185 audio_codec_2.pltype = payload_type - 1; | 228 audio_codec_2.pltype = payload_type - 1; |
186 EXPECT_EQ( | 229 EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(audio_codec_2, |
187 0, rtp_payload_registry.RegisterReceivePayload(audio_codec_2, &ignored)); | 230 &ignored)); |
188 | 231 |
189 EXPECT_FALSE(rtp_payload_registry.PayloadTypeToPayload(payload_type)) | 232 EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(payload_type)) |
190 << "The first payload should be " | 233 << "The first payload should be " |
191 "deregistered because the only thing that differs is payload type."; | 234 "deregistered because the only thing that differs is payload type."; |
192 EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type - 1)) | 235 EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type - 1)) |
193 << "The second payload should still be registered though."; | 236 << "The second payload should still be registered though."; |
194 | 237 |
195 // Now ensure non-compatible codecs aren't removed. Make |audio_codec_3| | 238 // Now ensure non-compatible codecs aren't removed. |
196 // incompatible by changing the frequency. | 239 ON_CALL(*mock_payload_strategy_, PayloadIsCompatible(_, _, _, _)) |
| 240 .WillByDefault(Return(false)); |
| 241 ExpectReturnOfTypicalAudioPayload(payload_type + 1, kTypicalRate); |
197 CodecInst audio_codec_3 = kTypicalAudioCodec; | 242 CodecInst audio_codec_3 = kTypicalAudioCodec; |
198 audio_codec_3.pltype = payload_type + 1; | 243 audio_codec_3.pltype = payload_type + 1; |
199 audio_codec_3.plfreq = kTypicalFrequency + 1; | 244 EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(audio_codec_3, |
200 EXPECT_EQ( | 245 &ignored)); |
201 0, rtp_payload_registry.RegisterReceivePayload(audio_codec_3, &ignored)); | |
202 | 246 |
203 EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type - 1)) | 247 EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type - 1)) |
204 << "Not compatible; both payloads should be kept."; | 248 << "Not compatible; both payloads should be kept."; |
205 EXPECT_TRUE(rtp_payload_registry.PayloadTypeToPayload(payload_type + 1)) | 249 EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type + 1)) |
206 << "Not compatible; both payloads should be kept."; | 250 << "Not compatible; both payloads should be kept."; |
207 } | 251 } |
208 | 252 |
209 TEST(RtpPayloadRegistryTest, | 253 TEST_F(RtpPayloadRegistryTest, |
210 LastReceivedCodecTypesAreResetWhenRegisteringNewPayloadTypes) { | 254 LastReceivedCodecTypesAreResetWhenRegisteringNewPayloadTypes) { |
211 RTPPayloadRegistry rtp_payload_registry; | 255 rtp_payload_registry_->set_last_received_payload_type(17); |
212 rtp_payload_registry.set_last_received_payload_type(17); | 256 EXPECT_EQ(17, rtp_payload_registry_->last_received_payload_type()); |
213 EXPECT_EQ(17, rtp_payload_registry.last_received_payload_type()); | |
214 | 257 |
215 bool media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18); | 258 bool media_type_unchanged = rtp_payload_registry_->ReportMediaPayloadType(18); |
216 EXPECT_FALSE(media_type_unchanged); | 259 EXPECT_FALSE(media_type_unchanged); |
217 media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18); | 260 media_type_unchanged = rtp_payload_registry_->ReportMediaPayloadType(18); |
218 EXPECT_TRUE(media_type_unchanged); | 261 EXPECT_TRUE(media_type_unchanged); |
219 | 262 |
220 bool ignored; | 263 bool ignored; |
| 264 ExpectReturnOfTypicalAudioPayload(34, kTypicalRate); |
221 CodecInst audio_codec = kTypicalAudioCodec; | 265 CodecInst audio_codec = kTypicalAudioCodec; |
222 audio_codec.pltype = 34; | 266 audio_codec.pltype = 34; |
223 EXPECT_EQ(0, | 267 EXPECT_EQ( |
224 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 268 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
225 | 269 |
226 EXPECT_EQ(-1, rtp_payload_registry.last_received_payload_type()); | 270 EXPECT_EQ(-1, rtp_payload_registry_->last_received_payload_type()); |
227 media_type_unchanged = rtp_payload_registry.ReportMediaPayloadType(18); | 271 media_type_unchanged = rtp_payload_registry_->ReportMediaPayloadType(18); |
228 EXPECT_FALSE(media_type_unchanged); | 272 EXPECT_FALSE(media_type_unchanged); |
229 } | 273 } |
230 | 274 |
231 class ParameterizedRtpPayloadRegistryTest | 275 class ParameterizedRtpPayloadRegistryTest |
232 : public ::testing::TestWithParam<int> {}; | 276 : public RtpPayloadRegistryTest, |
| 277 public ::testing::WithParamInterface<int> {}; |
233 | 278 |
234 TEST_P(ParameterizedRtpPayloadRegistryTest, | 279 TEST_P(ParameterizedRtpPayloadRegistryTest, |
235 FailsToRegisterKnownPayloadsWeAreNotInterestedIn) { | 280 FailsToRegisterKnownPayloadsWeAreNotInterestedIn) { |
236 RTPPayloadRegistry rtp_payload_registry; | 281 int payload_type = GetParam(); |
237 | 282 |
238 bool ignored; | 283 bool ignored; |
239 CodecInst audio_codec; | 284 CodecInst audio_codec; |
240 strncpy(audio_codec.plname, "whatever", RTP_PAYLOAD_NAME_SIZE); | 285 strncpy(audio_codec.plname, "whatever", RTP_PAYLOAD_NAME_SIZE); |
241 audio_codec.pltype = GetParam(); | 286 audio_codec.pltype = static_cast<uint8_t>(payload_type); |
242 audio_codec.plfreq = 1900; | 287 audio_codec.plfreq = 19; |
243 audio_codec.channels = 1; | 288 audio_codec.channels = 1; |
244 audio_codec.rate = 17; | 289 audio_codec.rate = 17; |
245 EXPECT_EQ(-1, | 290 EXPECT_EQ( |
246 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 291 -1, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
247 } | 292 } |
248 | 293 |
249 INSTANTIATE_TEST_CASE_P(TestKnownBadPayloadTypes, | 294 INSTANTIATE_TEST_CASE_P(TestKnownBadPayloadTypes, |
250 ParameterizedRtpPayloadRegistryTest, | 295 ParameterizedRtpPayloadRegistryTest, |
251 testing::Values(64, 72, 73, 74, 75, 76, 77, 78, 79)); | 296 testing::Values(64, 72, 73, 74, 75, 76, 77, 78, 79)); |
252 | 297 |
253 class RtpPayloadRegistryGenericTest : public ::testing::TestWithParam<int> {}; | 298 class RtpPayloadRegistryGenericTest |
| 299 : public RtpPayloadRegistryTest, |
| 300 public ::testing::WithParamInterface<int> {}; |
254 | 301 |
255 TEST_P(RtpPayloadRegistryGenericTest, RegisterGenericReceivePayloadType) { | 302 TEST_P(RtpPayloadRegistryGenericTest, RegisterGenericReceivePayloadType) { |
256 RTPPayloadRegistry rtp_payload_registry; | |
257 | |
258 bool ignored; | 303 bool ignored; |
259 CodecInst audio_codec; | 304 CodecInst audio_codec; |
260 // Dummy values, except for payload_type. | 305 // Dummy values, except for payload_type. |
261 strncpy(audio_codec.plname, "generic-codec", RTP_PAYLOAD_NAME_SIZE); | 306 strncpy(audio_codec.plname, "generic-codec", RTP_PAYLOAD_NAME_SIZE); |
262 audio_codec.pltype = GetParam(); | 307 audio_codec.pltype = GetParam(); |
263 audio_codec.plfreq = 1900; | 308 audio_codec.plfreq = 19; |
264 audio_codec.channels = 1; | 309 audio_codec.channels = 1; |
265 audio_codec.rate = 17; | 310 audio_codec.rate = 17; |
266 EXPECT_EQ(0, | 311 EXPECT_EQ( |
267 rtp_payload_registry.RegisterReceivePayload(audio_codec, &ignored)); | 312 0, rtp_payload_registry_->RegisterReceivePayload(audio_codec, &ignored)); |
268 } | 313 } |
269 | 314 |
270 // Generates an RTX packet for the given length and original sequence number. | 315 // Generates an RTX packet for the given length and original sequence number. |
271 // The RTX sequence number and ssrc will use the default value of 9999. The | 316 // The RTX sequence number and ssrc will use the default value of 9999. The |
272 // caller takes ownership of the returned buffer. | 317 // caller takes ownership of the returned buffer. |
273 const uint8_t* GenerateRtxPacket(size_t header_length, | 318 const uint8_t* GenerateRtxPacket(size_t header_length, |
274 size_t payload_length, | 319 size_t payload_length, |
275 uint16_t original_sequence_number) { | 320 uint16_t original_sequence_number) { |
276 uint8_t* packet = | 321 uint8_t* packet = |
277 new uint8_t[kRtxHeaderSize + header_length + payload_length](); | 322 new uint8_t[kRtxHeaderSize + header_length + payload_length](); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
332 header_parser->Parse(restored_packet.get(), length, &restored_header)); | 377 header_parser->Parse(restored_packet.get(), length, &restored_header)); |
333 EXPECT_EQ(original_sequence_number, restored_header.sequenceNumber) | 378 EXPECT_EQ(original_sequence_number, restored_header.sequenceNumber) |
334 << "The restored packet should have the original sequence number " | 379 << "The restored packet should have the original sequence number " |
335 << "in the correct location in the RTP header."; | 380 << "in the correct location in the RTP header."; |
336 EXPECT_EQ(expected_payload_type, restored_header.payloadType) | 381 EXPECT_EQ(expected_payload_type, restored_header.payloadType) |
337 << "The restored packet should have the correct payload type."; | 382 << "The restored packet should have the correct payload type."; |
338 EXPECT_EQ(original_ssrc, restored_header.ssrc) | 383 EXPECT_EQ(original_ssrc, restored_header.ssrc) |
339 << "The restored packet should have the correct ssrc."; | 384 << "The restored packet should have the correct ssrc."; |
340 } | 385 } |
341 | 386 |
342 TEST(RtpPayloadRegistryTest, MultipleRtxPayloadTypes) { | 387 TEST_F(RtpPayloadRegistryTest, MultipleRtxPayloadTypes) { |
343 RTPPayloadRegistry rtp_payload_registry; | |
344 // Set the incoming payload type to 90. | 388 // Set the incoming payload type to 90. |
345 RTPHeader header; | 389 RTPHeader header; |
346 header.payloadType = 90; | 390 header.payloadType = 90; |
347 header.ssrc = 1; | 391 header.ssrc = 1; |
348 rtp_payload_registry.SetIncomingPayloadType(header); | 392 rtp_payload_registry_->SetIncomingPayloadType(header); |
349 rtp_payload_registry.SetRtxSsrc(100); | 393 rtp_payload_registry_->SetRtxSsrc(100); |
350 // Map two RTX payload types. | 394 // Map two RTX payload types. |
351 rtp_payload_registry.SetRtxPayloadType(105, 95); | 395 rtp_payload_registry_->SetRtxPayloadType(105, 95); |
352 rtp_payload_registry.SetRtxPayloadType(106, 96); | 396 rtp_payload_registry_->SetRtxPayloadType(106, 96); |
353 | 397 |
354 TestRtxPacket(&rtp_payload_registry, 105, 95, true); | 398 TestRtxPacket(rtp_payload_registry_.get(), 105, 95, true); |
355 TestRtxPacket(&rtp_payload_registry, 106, 96, true); | 399 TestRtxPacket(rtp_payload_registry_.get(), 106, 96, true); |
356 } | 400 } |
357 | 401 |
358 TEST(RtpPayloadRegistryTest, InvalidRtxConfiguration) { | 402 TEST_F(RtpPayloadRegistryTest, InvalidRtxConfiguration) { |
359 RTPPayloadRegistry rtp_payload_registry; | 403 rtp_payload_registry_->SetRtxSsrc(100); |
360 rtp_payload_registry.SetRtxSsrc(100); | |
361 // Fails because no mappings exist and the incoming payload type isn't known. | 404 // Fails because no mappings exist and the incoming payload type isn't known. |
362 TestRtxPacket(&rtp_payload_registry, 105, 0, false); | 405 TestRtxPacket(rtp_payload_registry_.get(), 105, 0, false); |
363 // Succeeds when the mapping is used, but fails for the implicit fallback. | 406 // Succeeds when the mapping is used, but fails for the implicit fallback. |
364 rtp_payload_registry.SetRtxPayloadType(105, 95); | 407 rtp_payload_registry_->SetRtxPayloadType(105, 95); |
365 TestRtxPacket(&rtp_payload_registry, 105, 95, true); | 408 TestRtxPacket(rtp_payload_registry_.get(), 105, 95, true); |
366 TestRtxPacket(&rtp_payload_registry, 106, 0, false); | 409 TestRtxPacket(rtp_payload_registry_.get(), 106, 0, false); |
367 } | 410 } |
368 | 411 |
369 INSTANTIATE_TEST_CASE_P(TestDynamicRange, | 412 INSTANTIATE_TEST_CASE_P(TestDynamicRange, |
370 RtpPayloadRegistryGenericTest, | 413 RtpPayloadRegistryGenericTest, |
371 testing::Range(96, 127 + 1)); | 414 testing::Range(96, 127 + 1)); |
372 | 415 |
373 } // namespace webrtc | 416 } // namespace webrtc |
OLD | NEW |