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 #include <algorithm> | 10 #include <algorithm> |
(...skipping 1115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1126 TEST_F(EndToEndTest, UsesRtcpCompoundMode) { | 1126 TEST_F(EndToEndTest, UsesRtcpCompoundMode) { |
1127 RespectsRtcpMode(newapi::kRtcpCompound); | 1127 RespectsRtcpMode(newapi::kRtcpCompound); |
1128 } | 1128 } |
1129 | 1129 |
1130 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) { | 1130 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) { |
1131 RespectsRtcpMode(newapi::kRtcpReducedSize); | 1131 RespectsRtcpMode(newapi::kRtcpReducedSize); |
1132 } | 1132 } |
1133 | 1133 |
1134 // Test sets up a Call multiple senders with different resolutions and SSRCs. | 1134 // Test sets up a Call multiple senders with different resolutions and SSRCs. |
1135 // Another is set up to receive all three of these with different renderers. | 1135 // Another is set up to receive all three of these with different renderers. |
| 1136 class MultiStreamTest { |
| 1137 public: |
| 1138 static const size_t kNumStreams = 3; |
| 1139 struct CodecSettings { |
| 1140 uint32_t ssrc; |
| 1141 int width; |
| 1142 int height; |
| 1143 } codec_settings[kNumStreams]; |
| 1144 |
| 1145 MultiStreamTest() { |
| 1146 // TODO(sprang): Cleanup when msvc supports explicit initializers for array. |
| 1147 codec_settings[0] = {1, 640, 480}; |
| 1148 codec_settings[1] = {2, 320, 240}; |
| 1149 codec_settings[2] = {3, 240, 160}; |
| 1150 } |
| 1151 |
| 1152 virtual ~MultiStreamTest() {} |
| 1153 |
| 1154 void RunTest() { |
| 1155 rtc::scoped_ptr<test::DirectTransport> sender_transport( |
| 1156 CreateSendTransport()); |
| 1157 rtc::scoped_ptr<test::DirectTransport> receiver_transport( |
| 1158 CreateReceiveTransport()); |
| 1159 |
| 1160 rtc::scoped_ptr<Call> sender_call( |
| 1161 Call::Create(Call::Config(sender_transport.get()))); |
| 1162 rtc::scoped_ptr<Call> receiver_call( |
| 1163 Call::Create(Call::Config(receiver_transport.get()))); |
| 1164 sender_transport->SetReceiver(receiver_call->Receiver()); |
| 1165 receiver_transport->SetReceiver(sender_call->Receiver()); |
| 1166 |
| 1167 rtc::scoped_ptr<VideoEncoder> encoders[kNumStreams]; |
| 1168 for (size_t i = 0; i < kNumStreams; ++i) |
| 1169 encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8)); |
| 1170 |
| 1171 VideoSendStream* send_streams[kNumStreams]; |
| 1172 VideoReceiveStream* receive_streams[kNumStreams]; |
| 1173 |
| 1174 test::FrameGeneratorCapturer* frame_generators[kNumStreams]; |
| 1175 ScopedVector<VideoDecoder> allocated_decoders; |
| 1176 for (size_t i = 0; i < kNumStreams; ++i) { |
| 1177 uint32_t ssrc = codec_settings[i].ssrc; |
| 1178 int width = codec_settings[i].width; |
| 1179 int height = codec_settings[i].height; |
| 1180 |
| 1181 VideoSendStream::Config send_config; |
| 1182 send_config.rtp.ssrcs.push_back(ssrc); |
| 1183 send_config.encoder_settings.encoder = encoders[i].get(); |
| 1184 send_config.encoder_settings.payload_name = "VP8"; |
| 1185 send_config.encoder_settings.payload_type = 124; |
| 1186 VideoEncoderConfig encoder_config; |
| 1187 encoder_config.streams = test::CreateVideoStreams(1); |
| 1188 VideoStream* stream = &encoder_config.streams[0]; |
| 1189 stream->width = width; |
| 1190 stream->height = height; |
| 1191 stream->max_framerate = 5; |
| 1192 stream->min_bitrate_bps = stream->target_bitrate_bps = |
| 1193 stream->max_bitrate_bps = 100000; |
| 1194 |
| 1195 UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]); |
| 1196 |
| 1197 send_streams[i] = |
| 1198 sender_call->CreateVideoSendStream(send_config, encoder_config); |
| 1199 send_streams[i]->Start(); |
| 1200 |
| 1201 VideoReceiveStream::Config receive_config; |
| 1202 receive_config.rtp.remote_ssrc = ssrc; |
| 1203 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalSsrc; |
| 1204 VideoReceiveStream::Decoder decoder = |
| 1205 test::CreateMatchingDecoder(send_config.encoder_settings); |
| 1206 allocated_decoders.push_back(decoder.decoder); |
| 1207 receive_config.decoders.push_back(decoder); |
| 1208 |
| 1209 UpdateReceiveConfig(i, &receive_config); |
| 1210 |
| 1211 receive_streams[i] = |
| 1212 receiver_call->CreateVideoReceiveStream(receive_config); |
| 1213 receive_streams[i]->Start(); |
| 1214 |
| 1215 frame_generators[i] = test::FrameGeneratorCapturer::Create( |
| 1216 send_streams[i]->Input(), width, height, 30, |
| 1217 Clock::GetRealTimeClock()); |
| 1218 frame_generators[i]->Start(); |
| 1219 } |
| 1220 |
| 1221 Wait(); |
| 1222 |
| 1223 for (size_t i = 0; i < kNumStreams; ++i) { |
| 1224 frame_generators[i]->Stop(); |
| 1225 sender_call->DestroyVideoSendStream(send_streams[i]); |
| 1226 receiver_call->DestroyVideoReceiveStream(receive_streams[i]); |
| 1227 delete frame_generators[i]; |
| 1228 } |
| 1229 |
| 1230 sender_transport->StopSending(); |
| 1231 receiver_transport->StopSending(); |
| 1232 } |
| 1233 |
| 1234 protected: |
| 1235 virtual void Wait() = 0; |
| 1236 // Note: frame_generator is a point-to-pointer, since the actual instance |
| 1237 // hasn't been created at the time of this call. Only when packets/frames |
| 1238 // start flowing should this be dereferenced. |
| 1239 virtual void UpdateSendConfig( |
| 1240 size_t stream_index, |
| 1241 VideoSendStream::Config* send_config, |
| 1242 VideoEncoderConfig* encoder_config, |
| 1243 test::FrameGeneratorCapturer** frame_generator) {} |
| 1244 virtual void UpdateReceiveConfig(size_t stream_index, |
| 1245 VideoReceiveStream::Config* receive_config) { |
| 1246 } |
| 1247 virtual test::DirectTransport* CreateSendTransport() { |
| 1248 return new test::DirectTransport(); |
| 1249 } |
| 1250 virtual test::DirectTransport* CreateReceiveTransport() { |
| 1251 return new test::DirectTransport(); |
| 1252 } |
| 1253 }; |
| 1254 |
1136 // Each renderer verifies that it receives the expected resolution, and as soon | 1255 // Each renderer verifies that it receives the expected resolution, and as soon |
1137 // as every renderer has received a frame, the test finishes. | 1256 // as every renderer has received a frame, the test finishes. |
1138 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { | 1257 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { |
1139 static const size_t kNumStreams = 3; | |
1140 | |
1141 class VideoOutputObserver : public VideoRenderer { | 1258 class VideoOutputObserver : public VideoRenderer { |
1142 public: | 1259 public: |
1143 VideoOutputObserver(test::FrameGeneratorCapturer** capturer, | 1260 VideoOutputObserver(const MultiStreamTest::CodecSettings& settings, |
1144 int width, | 1261 uint32_t ssrc, |
1145 int height) | 1262 test::FrameGeneratorCapturer** frame_generator) |
1146 : capturer_(capturer), | 1263 : settings_(settings), |
1147 width_(width), | 1264 ssrc_(ssrc), |
1148 height_(height), | 1265 frame_generator_(frame_generator), |
1149 done_(EventWrapper::Create()) {} | 1266 done_(EventWrapper::Create()) {} |
1150 | 1267 |
1151 void RenderFrame(const VideoFrame& video_frame, | 1268 void RenderFrame(const VideoFrame& video_frame, |
1152 int time_to_render_ms) override { | 1269 int time_to_render_ms) override { |
1153 EXPECT_EQ(width_, video_frame.width()); | 1270 EXPECT_EQ(settings_.width, video_frame.width()); |
1154 EXPECT_EQ(height_, video_frame.height()); | 1271 EXPECT_EQ(settings_.height, video_frame.height()); |
1155 (*capturer_)->Stop(); | 1272 (*frame_generator_)->Stop(); |
1156 done_->Set(); | 1273 done_->Set(); |
1157 } | 1274 } |
1158 | 1275 |
| 1276 uint32_t Ssrc() { return ssrc_; } |
| 1277 |
1159 bool IsTextureSupported() const override { return false; } | 1278 bool IsTextureSupported() const override { return false; } |
1160 | 1279 |
1161 EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } | 1280 EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } |
1162 | 1281 |
1163 private: | 1282 private: |
1164 test::FrameGeneratorCapturer** capturer_; | 1283 const MultiStreamTest::CodecSettings& settings_; |
1165 int width_; | 1284 const uint32_t ssrc_; |
1166 int height_; | 1285 test::FrameGeneratorCapturer** const frame_generator_; |
1167 rtc::scoped_ptr<EventWrapper> done_; | 1286 rtc::scoped_ptr<EventWrapper> done_; |
1168 }; | 1287 }; |
1169 | 1288 |
1170 struct { | 1289 class Tester : public MultiStreamTest { |
1171 uint32_t ssrc; | 1290 public: |
1172 int width; | 1291 Tester() {} |
1173 int height; | 1292 virtual ~Tester() {} |
1174 } codec_settings[kNumStreams] = {{1, 640, 480}, {2, 320, 240}, {3, 240, 160}}; | 1293 |
1175 | 1294 protected: |
1176 test::DirectTransport sender_transport, receiver_transport; | 1295 void Wait() override { |
1177 rtc::scoped_ptr<Call> sender_call( | 1296 for (const auto& observer : observers_) { |
1178 Call::Create(Call::Config(&sender_transport))); | 1297 EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer->Wait()) |
1179 rtc::scoped_ptr<Call> receiver_call( | 1298 << "Time out waiting for from on ssrc " << observer->Ssrc(); |
1180 Call::Create(Call::Config(&receiver_transport))); | 1299 } |
1181 sender_transport.SetReceiver(receiver_call->Receiver()); | 1300 } |
1182 receiver_transport.SetReceiver(sender_call->Receiver()); | 1301 |
1183 | 1302 void UpdateSendConfig( |
1184 VideoSendStream* send_streams[kNumStreams]; | 1303 size_t stream_index, |
1185 VideoReceiveStream* receive_streams[kNumStreams]; | 1304 VideoSendStream::Config* send_config, |
1186 | 1305 VideoEncoderConfig* encoder_config, |
1187 VideoOutputObserver* observers[kNumStreams]; | 1306 test::FrameGeneratorCapturer** frame_generator) override { |
1188 test::FrameGeneratorCapturer* frame_generators[kNumStreams]; | 1307 observers_[stream_index].reset(new VideoOutputObserver( |
1189 | 1308 codec_settings[stream_index], send_config->rtp.ssrcs.front(), |
1190 rtc::scoped_ptr<VideoEncoder> encoders[kNumStreams]; | 1309 frame_generator)); |
1191 for (size_t i = 0; i < kNumStreams; ++i) | 1310 } |
1192 encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8)); | 1311 |
1193 | 1312 void UpdateReceiveConfig( |
1194 ScopedVector<VideoDecoder> allocated_decoders; | 1313 size_t stream_index, |
1195 for (size_t i = 0; i < kNumStreams; ++i) { | 1314 VideoReceiveStream::Config* receive_config) override { |
1196 uint32_t ssrc = codec_settings[i].ssrc; | 1315 receive_config->renderer = observers_[stream_index].get(); |
1197 int width = codec_settings[i].width; | 1316 } |
1198 int height = codec_settings[i].height; | 1317 |
1199 observers[i] = new VideoOutputObserver(&frame_generators[i], width, height); | 1318 private: |
1200 | 1319 rtc::scoped_ptr<VideoOutputObserver> observers_[kNumStreams]; |
1201 VideoSendStream::Config send_config; | 1320 } tester; |
1202 send_config.rtp.ssrcs.push_back(ssrc); | 1321 |
1203 send_config.encoder_settings.encoder = encoders[i].get(); | 1322 tester.RunTest(); |
1204 send_config.encoder_settings.payload_name = "VP8"; | |
1205 send_config.encoder_settings.payload_type = 124; | |
1206 VideoEncoderConfig encoder_config; | |
1207 encoder_config.streams = test::CreateVideoStreams(1); | |
1208 VideoStream* stream = &encoder_config.streams[0]; | |
1209 stream->width = width; | |
1210 stream->height = height; | |
1211 stream->max_framerate = 5; | |
1212 stream->min_bitrate_bps = stream->target_bitrate_bps = | |
1213 stream->max_bitrate_bps = 100000; | |
1214 send_streams[i] = | |
1215 sender_call->CreateVideoSendStream(send_config, encoder_config); | |
1216 send_streams[i]->Start(); | |
1217 | |
1218 VideoReceiveStream::Config receive_config; | |
1219 receive_config.renderer = observers[i]; | |
1220 receive_config.rtp.remote_ssrc = ssrc; | |
1221 receive_config.rtp.local_ssrc = kReceiverLocalSsrc; | |
1222 VideoReceiveStream::Decoder decoder = | |
1223 test::CreateMatchingDecoder(send_config.encoder_settings); | |
1224 allocated_decoders.push_back(decoder.decoder); | |
1225 receive_config.decoders.push_back(decoder); | |
1226 receive_streams[i] = | |
1227 receiver_call->CreateVideoReceiveStream(receive_config); | |
1228 receive_streams[i]->Start(); | |
1229 | |
1230 frame_generators[i] = test::FrameGeneratorCapturer::Create( | |
1231 send_streams[i]->Input(), width, height, 30, Clock::GetRealTimeClock()); | |
1232 frame_generators[i]->Start(); | |
1233 } | |
1234 | |
1235 for (size_t i = 0; i < kNumStreams; ++i) { | |
1236 EXPECT_EQ(kEventSignaled, observers[i]->Wait()) | |
1237 << "Timed out while waiting for observer " << i << " to render."; | |
1238 } | |
1239 | |
1240 for (size_t i = 0; i < kNumStreams; ++i) { | |
1241 frame_generators[i]->Stop(); | |
1242 sender_call->DestroyVideoSendStream(send_streams[i]); | |
1243 receiver_call->DestroyVideoReceiveStream(receive_streams[i]); | |
1244 delete frame_generators[i]; | |
1245 delete observers[i]; | |
1246 } | |
1247 | |
1248 sender_transport.StopSending(); | |
1249 receiver_transport.StopSending(); | |
1250 } | 1323 } |
1251 | 1324 |
| 1325 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) { |
| 1326 // TODO(sprang): Extend this to verify received values once send-side BWE |
| 1327 // is in place. |
| 1328 |
| 1329 static const int kExtensionId = 5; |
| 1330 |
| 1331 class RtpExtensionHeaderObserver : public test::DirectTransport { |
| 1332 public: |
| 1333 RtpExtensionHeaderObserver() |
| 1334 : done_(EventWrapper::Create()), |
| 1335 parser_(RtpHeaderParser::Create()), |
| 1336 last_seq_(0), |
| 1337 padding_observed_(false), |
| 1338 rtx_padding_observed_(false) { |
| 1339 parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, |
| 1340 kExtensionId); |
| 1341 } |
| 1342 virtual ~RtpExtensionHeaderObserver() {} |
| 1343 |
| 1344 bool SendRtp(const uint8_t* data, size_t length) override { |
| 1345 RTPHeader header; |
| 1346 EXPECT_TRUE(parser_->Parse(data, length, &header)); |
| 1347 if (header.extension.hasTransportSequenceNumber) { |
| 1348 if (!streams_observed_.empty()) { |
| 1349 EXPECT_EQ(static_cast<uint16_t>(last_seq_ + 1), |
| 1350 header.extension.transportSequenceNumber); |
| 1351 } |
| 1352 last_seq_ = header.extension.transportSequenceNumber; |
| 1353 |
| 1354 size_t payload_length = |
| 1355 length - (header.headerLength + header.paddingLength); |
| 1356 if (payload_length == 0) { |
| 1357 padding_observed_ = true; |
| 1358 } else if (header.payloadType == kSendRtxPayloadType) { |
| 1359 rtx_padding_observed_ = true; |
| 1360 } else { |
| 1361 streams_observed_.insert(header.ssrc); |
| 1362 } |
| 1363 |
| 1364 if (streams_observed_.size() == MultiStreamTest::kNumStreams && |
| 1365 padding_observed_ && rtx_padding_observed_) { |
| 1366 done_->Set(); |
| 1367 } |
| 1368 } |
| 1369 return test::DirectTransport::SendRtp(data, length); |
| 1370 } |
| 1371 |
| 1372 EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } |
| 1373 |
| 1374 rtc::scoped_ptr<EventWrapper> done_; |
| 1375 rtc::scoped_ptr<RtpHeaderParser> parser_; |
| 1376 uint16_t last_seq_; |
| 1377 std::set<uint32_t> streams_observed_; |
| 1378 bool padding_observed_; |
| 1379 bool rtx_padding_observed_; |
| 1380 }; |
| 1381 |
| 1382 class TransportSequenceNumberTester : public MultiStreamTest { |
| 1383 public: |
| 1384 TransportSequenceNumberTester() : observer_(nullptr) {} |
| 1385 virtual ~TransportSequenceNumberTester() {} |
| 1386 |
| 1387 protected: |
| 1388 void Wait() override { |
| 1389 DCHECK(observer_ != nullptr); |
| 1390 EXPECT_EQ(EventTypeWrapper::kEventSignaled, observer_->Wait()); |
| 1391 } |
| 1392 |
| 1393 void UpdateSendConfig( |
| 1394 size_t stream_index, |
| 1395 VideoSendStream::Config* send_config, |
| 1396 VideoEncoderConfig* encoder_config, |
| 1397 test::FrameGeneratorCapturer** frame_generator) override { |
| 1398 send_config->rtp.extensions.clear(); |
| 1399 send_config->rtp.extensions.push_back( |
| 1400 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); |
| 1401 |
| 1402 // Force some padding to be sent. |
| 1403 const int kPaddingBitrateBps = 50000; |
| 1404 int total_target_bitrate = 0; |
| 1405 for (const VideoStream& stream : encoder_config->streams) |
| 1406 total_target_bitrate += stream.target_bitrate_bps; |
| 1407 encoder_config->min_transmit_bitrate_bps = |
| 1408 total_target_bitrate + kPaddingBitrateBps; |
| 1409 |
| 1410 // Configure RTX for redundant payload padding. |
| 1411 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
| 1412 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); |
| 1413 send_config->rtp.rtx.payload_type = kSendRtxPayloadType; |
| 1414 } |
| 1415 |
| 1416 void UpdateReceiveConfig( |
| 1417 size_t stream_index, |
| 1418 VideoReceiveStream::Config* receive_config) override { |
| 1419 receive_config->rtp.extensions.clear(); |
| 1420 receive_config->rtp.extensions.push_back( |
| 1421 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); |
| 1422 } |
| 1423 |
| 1424 virtual test::DirectTransport* CreateSendTransport() { |
| 1425 observer_ = new RtpExtensionHeaderObserver(); |
| 1426 return observer_; |
| 1427 } |
| 1428 |
| 1429 private: |
| 1430 RtpExtensionHeaderObserver* observer_; |
| 1431 } tester; |
| 1432 |
| 1433 tester.RunTest(); |
| 1434 } |
| 1435 |
1252 TEST_F(EndToEndTest, ObserversEncodedFrames) { | 1436 TEST_F(EndToEndTest, ObserversEncodedFrames) { |
1253 class EncodedFrameTestObserver : public EncodedFrameObserver { | 1437 class EncodedFrameTestObserver : public EncodedFrameObserver { |
1254 public: | 1438 public: |
1255 EncodedFrameTestObserver() | 1439 EncodedFrameTestObserver() |
1256 : length_(0), | 1440 : length_(0), |
1257 frame_type_(kFrameEmpty), | 1441 frame_type_(kFrameEmpty), |
1258 called_(EventWrapper::Create()) {} | 1442 called_(EventWrapper::Create()) {} |
1259 virtual ~EncodedFrameTestObserver() {} | 1443 virtual ~EncodedFrameTestObserver() {} |
1260 | 1444 |
1261 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { | 1445 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { |
(...skipping 537 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1799 bool send_single_ssrc_first) { | 1983 bool send_single_ssrc_first) { |
1800 class SendsSetSsrcs : public test::EndToEndTest { | 1984 class SendsSetSsrcs : public test::EndToEndTest { |
1801 public: | 1985 public: |
1802 SendsSetSsrcs(const uint32_t* ssrcs, | 1986 SendsSetSsrcs(const uint32_t* ssrcs, |
1803 size_t num_ssrcs, | 1987 size_t num_ssrcs, |
1804 bool send_single_ssrc_first) | 1988 bool send_single_ssrc_first) |
1805 : EndToEndTest(kDefaultTimeoutMs), | 1989 : EndToEndTest(kDefaultTimeoutMs), |
1806 num_ssrcs_(num_ssrcs), | 1990 num_ssrcs_(num_ssrcs), |
1807 send_single_ssrc_first_(send_single_ssrc_first), | 1991 send_single_ssrc_first_(send_single_ssrc_first), |
1808 ssrcs_to_observe_(num_ssrcs), | 1992 ssrcs_to_observe_(num_ssrcs), |
1809 expect_single_ssrc_(send_single_ssrc_first) { | 1993 expect_single_ssrc_(send_single_ssrc_first), |
| 1994 send_stream_(nullptr) { |
1810 for (size_t i = 0; i < num_ssrcs; ++i) | 1995 for (size_t i = 0; i < num_ssrcs; ++i) |
1811 valid_ssrcs_[ssrcs[i]] = true; | 1996 valid_ssrcs_[ssrcs[i]] = true; |
1812 } | 1997 } |
1813 | 1998 |
1814 private: | 1999 private: |
1815 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 2000 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
1816 RTPHeader header; | 2001 RTPHeader header; |
1817 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | 2002 EXPECT_TRUE(parser_->Parse(packet, length, &header)); |
1818 | 2003 |
1819 EXPECT_TRUE(valid_ssrcs_[header.ssrc]) | 2004 EXPECT_TRUE(valid_ssrcs_[header.ssrc]) |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1891 | 2076 |
1892 RunBaseTest(&test); | 2077 RunBaseTest(&test); |
1893 } | 2078 } |
1894 | 2079 |
1895 TEST_F(EndToEndTest, ReportsSetEncoderRates) { | 2080 TEST_F(EndToEndTest, ReportsSetEncoderRates) { |
1896 class EncoderRateStatsTest : public test::EndToEndTest, | 2081 class EncoderRateStatsTest : public test::EndToEndTest, |
1897 public test::FakeEncoder { | 2082 public test::FakeEncoder { |
1898 public: | 2083 public: |
1899 EncoderRateStatsTest() | 2084 EncoderRateStatsTest() |
1900 : EndToEndTest(kDefaultTimeoutMs), | 2085 : EndToEndTest(kDefaultTimeoutMs), |
1901 FakeEncoder(Clock::GetRealTimeClock()) {} | 2086 FakeEncoder(Clock::GetRealTimeClock()), |
| 2087 send_stream_(nullptr), |
| 2088 bitrate_kbps_(0) {} |
1902 | 2089 |
1903 void OnStreamsCreated( | 2090 void OnStreamsCreated( |
1904 VideoSendStream* send_stream, | 2091 VideoSendStream* send_stream, |
1905 const std::vector<VideoReceiveStream*>& receive_streams) override { | 2092 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1906 send_stream_ = send_stream; | 2093 send_stream_ = send_stream; |
1907 } | 2094 } |
1908 | 2095 |
1909 void ModifyConfigs(VideoSendStream::Config* send_config, | 2096 void ModifyConfigs(VideoSendStream::Config* send_config, |
1910 std::vector<VideoReceiveStream::Config>* receive_configs, | 2097 std::vector<VideoReceiveStream::Config>* receive_configs, |
1911 VideoEncoderConfig* encoder_config) override { | 2098 VideoEncoderConfig* encoder_config) override { |
(...skipping 615 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2527 static const int kNumAcceptedDowntimeRtp = 5; | 2714 static const int kNumAcceptedDowntimeRtp = 5; |
2528 // A single RTCP may be in the pipeline. | 2715 // A single RTCP may be in the pipeline. |
2529 static const int kNumAcceptedDowntimeRtcp = 1; | 2716 static const int kNumAcceptedDowntimeRtcp = 1; |
2530 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { | 2717 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { |
2531 public: | 2718 public: |
2532 NetworkStateTest() | 2719 NetworkStateTest() |
2533 : EndToEndTest(kDefaultTimeoutMs), | 2720 : EndToEndTest(kDefaultTimeoutMs), |
2534 FakeEncoder(Clock::GetRealTimeClock()), | 2721 FakeEncoder(Clock::GetRealTimeClock()), |
2535 encoded_frames_(EventWrapper::Create()), | 2722 encoded_frames_(EventWrapper::Create()), |
2536 packet_event_(EventWrapper::Create()), | 2723 packet_event_(EventWrapper::Create()), |
| 2724 sender_call_(nullptr), |
| 2725 receiver_call_(nullptr), |
2537 sender_state_(kNetworkUp), | 2726 sender_state_(kNetworkUp), |
2538 sender_rtp_(0), | 2727 sender_rtp_(0), |
2539 sender_rtcp_(0), | 2728 sender_rtcp_(0), |
2540 receiver_rtcp_(0), | 2729 receiver_rtcp_(0), |
2541 down_frames_(0) {} | 2730 down_frames_(0) {} |
2542 | 2731 |
2543 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 2732 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
2544 rtc::CritScope lock(&test_crit_); | 2733 rtc::CritScope lock(&test_crit_); |
2545 ++sender_rtp_; | 2734 ++sender_rtp_; |
2546 packet_event_->Set(); | 2735 packet_event_->Set(); |
(...skipping 309 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2856 EXPECT_TRUE(default_receive_config.rtp.rtx.empty()) | 3045 EXPECT_TRUE(default_receive_config.rtp.rtx.empty()) |
2857 << "Enabling RTX requires rtpmap: rtx negotiation."; | 3046 << "Enabling RTX requires rtpmap: rtx negotiation."; |
2858 EXPECT_TRUE(default_receive_config.rtp.extensions.empty()) | 3047 EXPECT_TRUE(default_receive_config.rtp.extensions.empty()) |
2859 << "Enabling RTP extensions require negotiation."; | 3048 << "Enabling RTP extensions require negotiation."; |
2860 | 3049 |
2861 VerifyEmptyNackConfig(default_receive_config.rtp.nack); | 3050 VerifyEmptyNackConfig(default_receive_config.rtp.nack); |
2862 VerifyEmptyFecConfig(default_receive_config.rtp.fec); | 3051 VerifyEmptyFecConfig(default_receive_config.rtp.fec); |
2863 } | 3052 } |
2864 | 3053 |
2865 } // namespace webrtc | 3054 } // namespace webrtc |
OLD | NEW |