OLD | NEW |
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2004 Google Inc. | 3 * Copyright 2004 Google Inc. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions are met: | 6 * modification, are permitted provided that the following conditions are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright notice, | 8 * 1. Redistributions of source code must retain the above copyright notice, |
9 * this list of conditions and the following disclaimer. | 9 * this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | 10 * 2. Redistributions in binary form must reproduce the above copyright notice, |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
52 | 52 |
53 static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0); | 53 static const cricket::VideoCodec kVp8Codec(100, "VP8", 640, 400, 30, 0); |
54 static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0); | 54 static const cricket::VideoCodec kVp9Codec(101, "VP9", 640, 400, 30, 0); |
55 static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0); | 55 static const cricket::VideoCodec kH264Codec(102, "H264", 640, 400, 30, 0); |
56 | 56 |
57 static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0); | 57 static const cricket::VideoCodec kRedCodec(116, "red", 0, 0, 0, 0); |
58 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0); | 58 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec", 0, 0, 0, 0); |
59 | 59 |
60 static const uint8_t kRedRtxPayloadType = 125; | 60 static const uint8_t kRedRtxPayloadType = 125; |
61 | 61 |
62 static const uint32 kSsrcs1[] = {1}; | 62 static const uint32_t kSsrcs1[] = {1}; |
63 static const uint32 kSsrcs3[] = {1, 2, 3}; | 63 static const uint32_t kSsrcs3[] = {1, 2, 3}; |
64 static const uint32 kRtxSsrcs1[] = {4}; | 64 static const uint32_t kRtxSsrcs1[] = {4}; |
65 static const uint32 kIncomingUnsignalledSsrc = 0xC0FFEE; | 65 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; |
66 static const char kUnsupportedExtensionName[] = | 66 static const char kUnsupportedExtensionName[] = |
67 "urn:ietf:params:rtp-hdrext:unsupported"; | 67 "urn:ietf:params:rtp-hdrext:unsupported"; |
68 | 68 |
69 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { | 69 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { |
70 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 70 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
71 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); | 71 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); |
72 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 72 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
73 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli))); | 73 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli))); |
74 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 74 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
75 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty))); | 75 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty))); |
(...skipping 404 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
480 channel->SetSend(true); | 480 channel->SetSend(true); |
481 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; | 481 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; |
482 | 482 |
483 FakeVideoCapturer capturer1; | 483 FakeVideoCapturer capturer1; |
484 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1)); | 484 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1)); |
485 | 485 |
486 cricket::CapturedFrame frame; | 486 cricket::CapturedFrame frame; |
487 frame.width = 1280; | 487 frame.width = 1280; |
488 frame.height = 720; | 488 frame.height = 720; |
489 frame.fourcc = cricket::FOURCC_I420; | 489 frame.fourcc = cricket::FOURCC_I420; |
490 frame.data_size = static_cast<uint32>( | 490 frame.data_size = static_cast<uint32_t>( |
491 cricket::VideoFrame::SizeOf(frame.width, frame.height)); | 491 cricket::VideoFrame::SizeOf(frame.width, frame.height)); |
492 rtc::scoped_ptr<char[]> data(new char[frame.data_size]); | 492 rtc::scoped_ptr<char[]> data(new char[frame.data_size]); |
493 frame.data = data.get(); | 493 frame.data = data.get(); |
494 memset(frame.data, 1, frame.data_size); | 494 memset(frame.data, 1, frame.data_size); |
495 const int kInitialTimestamp = 123456; | 495 const int kInitialTimestamp = 123456; |
496 frame.time_stamp = kInitialTimestamp; | 496 frame.time_stamp = kInitialTimestamp; |
497 | 497 |
498 // Deliver initial frame. | 498 // Deliver initial frame. |
499 capturer1.SignalCapturedFrame(&frame); | 499 capturer1.SignalCapturedFrame(&frame); |
500 // Deliver next frame 1 second later. | 500 // Deliver next frame 1 second later. |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
552 | 552 |
553 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { | 553 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { |
554 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 554 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
555 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); | 555 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
556 std::vector<cricket::VideoCodec> codecs; | 556 std::vector<cricket::VideoCodec> codecs; |
557 codecs.push_back(kVp8Codec); | 557 codecs.push_back(kVp8Codec); |
558 | 558 |
559 rtc::scoped_ptr<VideoMediaChannel> channel( | 559 rtc::scoped_ptr<VideoMediaChannel> channel( |
560 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 560 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
561 | 561 |
562 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); | 562 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
563 | 563 |
564 EXPECT_TRUE( | 564 EXPECT_TRUE( |
565 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); | 565 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
566 EXPECT_TRUE(channel->SetSend(true)); | 566 EXPECT_TRUE(channel->SetSend(true)); |
567 | 567 |
568 cricket::FakeVideoCapturer capturer; | 568 cricket::FakeVideoCapturer capturer; |
569 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); | 569 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); |
570 EXPECT_EQ(cricket::CS_RUNNING, | 570 EXPECT_EQ(cricket::CS_RUNNING, |
571 capturer.Start(capturer.GetSupportedFormats()->front())); | 571 capturer.Start(capturer.GetSupportedFormats()->front())); |
572 EXPECT_TRUE(capturer.CaptureFrame()); | 572 EXPECT_TRUE(capturer.CaptureFrame()); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
630 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 630 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
631 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); | 631 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
632 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); | 632 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
633 | 633 |
634 std::vector<cricket::VideoCodec> codecs; | 634 std::vector<cricket::VideoCodec> codecs; |
635 codecs.push_back(kVp8Codec); | 635 codecs.push_back(kVp8Codec); |
636 | 636 |
637 rtc::scoped_ptr<VideoMediaChannel> channel( | 637 rtc::scoped_ptr<VideoMediaChannel> channel( |
638 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 638 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
639 | 639 |
640 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); | 640 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
641 | 641 |
642 EXPECT_TRUE( | 642 EXPECT_TRUE( |
643 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); | 643 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
644 EXPECT_TRUE(channel->SetSend(true)); | 644 EXPECT_TRUE(channel->SetSend(true)); |
645 | 645 |
646 // Send a fake frame, or else the media engine will configure the simulcast | 646 // Send a fake frame, or else the media engine will configure the simulcast |
647 // encoder adapter at a low-enough size that it'll only create a single | 647 // encoder adapter at a low-enough size that it'll only create a single |
648 // encoder layer. | 648 // encoder layer. |
649 cricket::FakeVideoCapturer capturer; | 649 cricket::FakeVideoCapturer capturer; |
650 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); | 650 EXPECT_TRUE(channel->SetCapturer(ssrcs.front(), &capturer)); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
686 | 686 |
687 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { | 687 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { |
688 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 688 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
689 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); | 689 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264"); |
690 std::vector<cricket::VideoCodec> codecs; | 690 std::vector<cricket::VideoCodec> codecs; |
691 codecs.push_back(kH264Codec); | 691 codecs.push_back(kH264Codec); |
692 | 692 |
693 rtc::scoped_ptr<VideoMediaChannel> channel( | 693 rtc::scoped_ptr<VideoMediaChannel> channel( |
694 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 694 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
695 | 695 |
696 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); | 696 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
697 EXPECT_TRUE( | 697 EXPECT_TRUE( |
698 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs))); | 698 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs))); |
699 // Set the stream to 720p. This should trigger a "real" encoder | 699 // Set the stream to 720p. This should trigger a "real" encoder |
700 // initialization. | 700 // initialization. |
701 cricket::VideoFormat format( | 701 cricket::VideoFormat format( |
702 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); | 702 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); |
703 EXPECT_TRUE(channel->SetSendStreamFormat(ssrcs[0], format)); | 703 EXPECT_TRUE(channel->SetSendStreamFormat(ssrcs[0], format)); |
704 ASSERT_EQ(1u, encoder_factory.encoders().size()); | 704 ASSERT_EQ(1u, encoder_factory.encoders().size()); |
705 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0]; | 705 FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0]; |
706 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType); | 706 EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType); |
(...skipping 361 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1068 return AddSendStream( | 1068 return AddSendStream( |
1069 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); | 1069 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
1070 } | 1070 } |
1071 return AddSendStream(CreateSimStreamParams("cname", ssrcs)); | 1071 return AddSendStream(CreateSimStreamParams("cname", ssrcs)); |
1072 } | 1072 } |
1073 | 1073 |
1074 rtc::scoped_ptr<FakeCall> fake_call_; | 1074 rtc::scoped_ptr<FakeCall> fake_call_; |
1075 rtc::scoped_ptr<VideoMediaChannel> channel_; | 1075 rtc::scoped_ptr<VideoMediaChannel> channel_; |
1076 cricket::VideoSendParameters send_parameters_; | 1076 cricket::VideoSendParameters send_parameters_; |
1077 cricket::VideoRecvParameters recv_parameters_; | 1077 cricket::VideoRecvParameters recv_parameters_; |
1078 uint32 last_ssrc_; | 1078 uint32_t last_ssrc_; |
1079 }; | 1079 }; |
1080 | 1080 |
1081 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) { | 1081 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) { |
1082 const uint32 kVideoSsrc = 123; | 1082 const uint32_t kVideoSsrc = 123; |
1083 const std::string kSyncLabel = "AvSyncLabel"; | 1083 const std::string kSyncLabel = "AvSyncLabel"; |
1084 | 1084 |
1085 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc); | 1085 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc); |
1086 sp.sync_label = kSyncLabel; | 1086 sp.sync_label = kSyncLabel; |
1087 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 1087 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
1088 | 1088 |
1089 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size()); | 1089 EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size()); |
1090 EXPECT_EQ(kSyncLabel, | 1090 EXPECT_EQ(kSyncLabel, |
1091 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group) | 1091 fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group) |
1092 << "SyncGroup should be set based on sync_label"; | 1092 << "SyncGroup should be set based on sync_label"; |
1093 } | 1093 } |
1094 | 1094 |
1095 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) { | 1095 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) { |
1096 cricket::VideoSendParameters parameters; | 1096 cricket::VideoSendParameters parameters; |
1097 parameters.codecs = engine_.codecs(); | 1097 parameters.codecs = engine_.codecs(); |
1098 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1098 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1099 EXPECT_TRUE(channel_->SetSend(true)); | 1099 EXPECT_TRUE(channel_->SetSend(true)); |
1100 parameters.options.conference_mode.Set(true); | 1100 parameters.options.conference_mode.Set(true); |
1101 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1101 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1102 | 1102 |
1103 // Send side. | 1103 // Send side. |
1104 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); | 1104 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
1105 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 1105 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
1106 FakeVideoSendStream* send_stream = AddSendStream( | 1106 FakeVideoSendStream* send_stream = AddSendStream( |
1107 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); | 1107 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
1108 | 1108 |
1109 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size()); | 1109 ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size()); |
1110 for (size_t i = 0; i < rtx_ssrcs.size(); ++i) | 1110 for (size_t i = 0; i < rtx_ssrcs.size(); ++i) |
1111 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]); | 1111 EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]); |
1112 | 1112 |
1113 // Receiver side. | 1113 // Receiver side. |
1114 FakeVideoReceiveStream* recv_stream = AddRecvStream( | 1114 FakeVideoReceiveStream* recv_stream = AddRecvStream( |
1115 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); | 1115 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
(...skipping 726 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1842 } | 1842 } |
1843 | 1843 |
1844 TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) { | 1844 TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) { |
1845 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); | 1845 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); |
1846 | 1846 |
1847 VideoCodec codec; | 1847 VideoCodec codec; |
1848 EXPECT_TRUE(channel_->GetSendCodec(&codec)); | 1848 EXPECT_TRUE(channel_->GetSendCodec(&codec)); |
1849 EXPECT_TRUE(codec.Matches(engine_.codecs()[0])); | 1849 EXPECT_TRUE(codec.Matches(engine_.codecs()[0])); |
1850 | 1850 |
1851 // Using a RTX setup to verify that the default RTX payload type is good. | 1851 // Using a RTX setup to verify that the default RTX payload type is good. |
1852 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); | 1852 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
1853 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 1853 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
1854 FakeVideoSendStream* stream = AddSendStream( | 1854 FakeVideoSendStream* stream = AddSendStream( |
1855 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); | 1855 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
1856 webrtc::VideoSendStream::Config config = stream->GetConfig(); | 1856 webrtc::VideoSendStream::Config config = stream->GetConfig(); |
1857 | 1857 |
1858 // Make sure NACK and FEC are enabled on the correct payload types. | 1858 // Make sure NACK and FEC are enabled on the correct payload types. |
1859 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); | 1859 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); |
1860 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type); | 1860 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type); |
1861 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type); | 1861 EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type); |
1862 | 1862 |
1863 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); | 1863 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); |
(...skipping 700 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2564 info.bw_estimations[0].actual_enc_bitrate); | 2564 info.bw_estimations[0].actual_enc_bitrate); |
2565 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate) | 2565 EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate) |
2566 << "Bandwidth stats should take all streams into account."; | 2566 << "Bandwidth stats should take all streams into account."; |
2567 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate) | 2567 EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate) |
2568 << "Bandwidth stats should take all streams into account."; | 2568 << "Bandwidth stats should take all streams into account."; |
2569 } | 2569 } |
2570 | 2570 |
2571 TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) { | 2571 TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) { |
2572 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2572 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
2573 | 2573 |
2574 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); | 2574 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
2575 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 2575 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
2576 | 2576 |
2577 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); | 2577 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); |
2578 const size_t kDataLength = 12; | 2578 const size_t kDataLength = 12; |
2579 uint8_t data[kDataLength]; | 2579 uint8_t data[kDataLength]; |
2580 memset(data, 0, sizeof(data)); | 2580 memset(data, 0, sizeof(data)); |
2581 rtc::SetBE32(&data[8], ssrcs[0]); | 2581 rtc::SetBE32(&data[8], ssrcs[0]); |
2582 rtc::Buffer packet(data, kDataLength); | 2582 rtc::Buffer packet(data, kDataLength); |
2583 rtc::PacketTime packet_time; | 2583 rtc::PacketTime packet_time; |
2584 channel_->OnPacketReceived(&packet, packet_time); | 2584 channel_->OnPacketReceived(&packet, packet_time); |
2585 | 2585 |
2586 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) | 2586 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) |
2587 << "No default receive stream created."; | 2587 << "No default receive stream created."; |
2588 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0]; | 2588 FakeVideoReceiveStream* recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
2589 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size()) | 2589 EXPECT_EQ(0u, recv_stream->GetConfig().rtp.rtx.size()) |
2590 << "Default receive stream should not have configured RTX"; | 2590 << "Default receive stream should not have configured RTX"; |
2591 | 2591 |
2592 EXPECT_TRUE(channel_->AddRecvStream( | 2592 EXPECT_TRUE(channel_->AddRecvStream( |
2593 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs))); | 2593 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs))); |
2594 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) | 2594 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) |
2595 << "AddRecvStream should've reconfigured, not added a new receiver."; | 2595 << "AddRecvStream should've reconfigured, not added a new receiver."; |
2596 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; | 2596 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
2597 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size()); | 2597 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size()); |
2598 EXPECT_EQ(rtx_ssrcs[0], | 2598 EXPECT_EQ(rtx_ssrcs[0], |
2599 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc); | 2599 recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc); |
2600 } | 2600 } |
2601 | 2601 |
2602 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) { | 2602 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) { |
2603 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2603 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
2604 | 2604 |
2605 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); | 2605 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
2606 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 2606 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
2607 | 2607 |
2608 StreamParams sp = | 2608 StreamParams sp = |
2609 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); | 2609 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); |
2610 sp.ssrcs = ssrcs; // Without RTXs, this is the important part. | 2610 sp.ssrcs = ssrcs; // Without RTXs, this is the important part. |
2611 | 2611 |
2612 EXPECT_FALSE(channel_->AddSendStream(sp)); | 2612 EXPECT_FALSE(channel_->AddSendStream(sp)); |
2613 EXPECT_FALSE(channel_->AddRecvStream(sp)); | 2613 EXPECT_FALSE(channel_->AddRecvStream(sp)); |
2614 } | 2614 } |
2615 | 2615 |
2616 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) { | 2616 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) { |
2617 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2617 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
2618 | 2618 |
2619 const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1); | 2619 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
2620 const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 2620 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
2621 | 2621 |
2622 StreamParams sp = | 2622 StreamParams sp = |
2623 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); | 2623 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs); |
2624 | 2624 |
2625 EXPECT_TRUE(channel_->AddSendStream(sp)); | 2625 EXPECT_TRUE(channel_->AddSendStream(sp)); |
2626 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 2626 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
2627 | 2627 |
2628 // The RTX SSRC is already used in previous streams, using it should fail. | 2628 // The RTX SSRC is already used in previous streams, using it should fail. |
2629 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]); | 2629 sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]); |
2630 EXPECT_FALSE(channel_->AddSendStream(sp)); | 2630 EXPECT_FALSE(channel_->AddSendStream(sp)); |
2631 EXPECT_FALSE(channel_->AddRecvStream(sp)); | 2631 EXPECT_FALSE(channel_->AddRecvStream(sp)); |
2632 | 2632 |
2633 // After removing the original stream this should be fine to add (makes sure | 2633 // After removing the original stream this should be fine to add (makes sure |
2634 // that RTX ssrcs are not forever taken). | 2634 // that RTX ssrcs are not forever taken). |
2635 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0])); | 2635 EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0])); |
2636 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0])); | 2636 EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0])); |
2637 EXPECT_TRUE(channel_->AddSendStream(sp)); | 2637 EXPECT_TRUE(channel_->AddSendStream(sp)); |
2638 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 2638 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
2639 } | 2639 } |
2640 | 2640 |
2641 TEST_F(WebRtcVideoChannel2Test, | 2641 TEST_F(WebRtcVideoChannel2Test, |
2642 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) { | 2642 RejectsAddingStreamsWithOverlappingSimulcastSsrcs) { |
2643 static const uint32 kFirstStreamSsrcs[] = {1, 2, 3}; | 2643 static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3}; |
2644 static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5}; | 2644 static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5}; |
2645 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2645 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
2646 | 2646 |
2647 StreamParams sp = | 2647 StreamParams sp = |
2648 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs)); | 2648 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs)); |
2649 | 2649 |
2650 EXPECT_TRUE(channel_->AddSendStream(sp)); | 2650 EXPECT_TRUE(channel_->AddSendStream(sp)); |
2651 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 2651 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
2652 | 2652 |
2653 // One of the SSRCs is already used in previous streams, using it should fail. | 2653 // One of the SSRCs is already used in previous streams, using it should fail. |
2654 sp = cricket::CreateSimStreamParams("cname", | 2654 sp = cricket::CreateSimStreamParams("cname", |
(...skipping 305 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2960 void VerifySimulcastSettings(const VideoCodec& codec, | 2960 void VerifySimulcastSettings(const VideoCodec& codec, |
2961 VideoOptions::HighestBitrate bitrate_mode, | 2961 VideoOptions::HighestBitrate bitrate_mode, |
2962 size_t num_configured_streams, | 2962 size_t num_configured_streams, |
2963 size_t expected_num_streams, | 2963 size_t expected_num_streams, |
2964 SimulcastBitrateMode simulcast_bitrate_mode) { | 2964 SimulcastBitrateMode simulcast_bitrate_mode) { |
2965 cricket::VideoSendParameters parameters; | 2965 cricket::VideoSendParameters parameters; |
2966 parameters.options.video_highest_bitrate.Set(bitrate_mode); | 2966 parameters.options.video_highest_bitrate.Set(bitrate_mode); |
2967 parameters.codecs.push_back(codec); | 2967 parameters.codecs.push_back(codec); |
2968 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2968 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2969 | 2969 |
2970 std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3); | 2970 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
2971 RTC_DCHECK(num_configured_streams <= ssrcs.size()); | 2971 RTC_DCHECK(num_configured_streams <= ssrcs.size()); |
2972 ssrcs.resize(num_configured_streams); | 2972 ssrcs.resize(num_configured_streams); |
2973 | 2973 |
2974 FakeVideoSendStream* stream = | 2974 FakeVideoSendStream* stream = |
2975 AddSendStream(CreateSimStreamParams("cname", ssrcs)); | 2975 AddSendStream(CreateSimStreamParams("cname", ssrcs)); |
2976 // Send a full-size frame to trigger a stream reconfiguration to use all | 2976 // Send a full-size frame to trigger a stream reconfiguration to use all |
2977 // expected simulcast layers. | 2977 // expected simulcast layers. |
2978 cricket::FakeVideoCapturer capturer; | 2978 cricket::FakeVideoCapturer capturer; |
2979 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer)); | 2979 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer)); |
2980 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat( | 2980 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat( |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3069 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 3069 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
3070 std::vector<FakeVideoReceiveStream*> streams = | 3070 std::vector<FakeVideoReceiveStream*> streams = |
3071 fake_call_.GetVideoReceiveStreams(); | 3071 fake_call_.GetVideoReceiveStreams(); |
3072 EXPECT_EQ(num_streams + 1, streams.size()); | 3072 EXPECT_EQ(num_streams + 1, streams.size()); |
3073 return streams[streams.size() - 1]; | 3073 return streams[streams.size() - 1]; |
3074 } | 3074 } |
3075 | 3075 |
3076 FakeCall fake_call_; | 3076 FakeCall fake_call_; |
3077 WebRtcVideoEngine2 engine_; | 3077 WebRtcVideoEngine2 engine_; |
3078 rtc::scoped_ptr<VideoMediaChannel> channel_; | 3078 rtc::scoped_ptr<VideoMediaChannel> channel_; |
3079 uint32 last_ssrc_; | 3079 uint32_t last_ssrc_; |
3080 }; | 3080 }; |
3081 | 3081 |
3082 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { | 3082 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { |
3083 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); | 3083 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); |
3084 } | 3084 } |
3085 | 3085 |
3086 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { | 3086 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { |
3087 VerifySimulcastSettings( | 3087 VerifySimulcastSettings( |
3088 kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL); | 3088 kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL); |
3089 } | 3089 } |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3193 // Ensures that the correct settings are applied to the codec when two temporal | 3193 // Ensures that the correct settings are applied to the codec when two temporal |
3194 // layer screencasting is enabled, and that the correct simulcast settings are | 3194 // layer screencasting is enabled, and that the correct simulcast settings are |
3195 // reapplied when disabling screencasting. | 3195 // reapplied when disabling screencasting. |
3196 TEST_F(WebRtcVideoChannel2SimulcastTest, | 3196 TEST_F(WebRtcVideoChannel2SimulcastTest, |
3197 DISABLED_TwoTemporalLayerScreencastSettings) { | 3197 DISABLED_TwoTemporalLayerScreencastSettings) { |
3198 // TODO(pbos): Implement. | 3198 // TODO(pbos): Implement. |
3199 FAIL() << "Not implemented."; | 3199 FAIL() << "Not implemented."; |
3200 } | 3200 } |
3201 | 3201 |
3202 } // namespace cricket | 3202 } // namespace cricket |
OLD | NEW |