OLD | NEW |
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 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 451 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
462 virtual void SetUp() { | 462 virtual void SetUp() { |
463 cricket::Device device("test", "device"); | 463 cricket::Device device("test", "device"); |
464 engine_.Init(); | 464 engine_.Init(); |
465 channel_.reset( | 465 channel_.reset( |
466 engine_.CreateChannel(call_.get(), cricket::VideoOptions())); | 466 engine_.CreateChannel(call_.get(), cricket::VideoOptions())); |
467 EXPECT_TRUE(channel_.get() != NULL); | 467 EXPECT_TRUE(channel_.get() != NULL); |
468 ConnectVideoChannelError(); | 468 ConnectVideoChannelError(); |
469 network_interface_.SetDestination(channel_.get()); | 469 network_interface_.SetDestination(channel_.get()); |
470 channel_->SetInterface(&network_interface_); | 470 channel_->SetInterface(&network_interface_); |
471 media_error_ = cricket::VideoMediaChannel::ERROR_NONE; | 471 media_error_ = cricket::VideoMediaChannel::ERROR_NONE; |
472 channel_->SetRecvCodecs(engine_.codecs()); | 472 cricket::VideoRecvParameters parameters; |
| 473 parameters.codecs = engine_.codecs(); |
| 474 channel_->SetRecvParameters(parameters); |
473 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams())); | 475 EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams())); |
474 video_capturer_.reset(CreateFakeVideoCapturer()); | 476 video_capturer_.reset(CreateFakeVideoCapturer()); |
475 cricket::VideoFormat format(640, 480, | 477 cricket::VideoFormat format(640, 480, |
476 cricket::VideoFormat::FpsToInterval(30), | 478 cricket::VideoFormat::FpsToInterval(30), |
477 cricket::FOURCC_I420); | 479 cricket::FOURCC_I420); |
478 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format)); | 480 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format)); |
479 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get())); | 481 EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get())); |
480 } | 482 } |
481 | 483 |
482 virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() { | 484 virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
523 &VideoMediaChannelTest<E, C>::OnVideoChannelError); | 525 &VideoMediaChannelTest<E, C>::OnVideoChannelError); |
524 } | 526 } |
525 bool SetDefaultCodec() { | 527 bool SetDefaultCodec() { |
526 return SetOneCodec(DefaultCodec()); | 528 return SetOneCodec(DefaultCodec()); |
527 } | 529 } |
528 | 530 |
529 bool SetOneCodec(int pt, const char* name, int w, int h, int fr) { | 531 bool SetOneCodec(int pt, const char* name, int w, int h, int fr) { |
530 return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr, 0)); | 532 return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr, 0)); |
531 } | 533 } |
532 bool SetOneCodec(const cricket::VideoCodec& codec) { | 534 bool SetOneCodec(const cricket::VideoCodec& codec) { |
533 std::vector<cricket::VideoCodec> codecs; | |
534 codecs.push_back(codec); | |
535 | |
536 cricket::VideoFormat capture_format(codec.width, codec.height, | 535 cricket::VideoFormat capture_format(codec.width, codec.height, |
537 cricket::VideoFormat::FpsToInterval(codec.framerate), | 536 cricket::VideoFormat::FpsToInterval(codec.framerate), |
538 cricket::FOURCC_I420); | 537 cricket::FOURCC_I420); |
539 | 538 |
540 if (video_capturer_) { | 539 if (video_capturer_) { |
541 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format)); | 540 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(capture_format)); |
542 } | 541 } |
543 if (video_capturer_2_) { | 542 if (video_capturer_2_) { |
544 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format)); | 543 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(capture_format)); |
545 } | 544 } |
546 | 545 |
547 bool sending = channel_->sending(); | 546 bool sending = channel_->sending(); |
548 bool success = SetSend(false); | 547 bool success = SetSend(false); |
549 if (success) | 548 if (success) { |
550 success = channel_->SetSendCodecs(codecs); | 549 cricket::VideoSendParameters parameters; |
551 if (success) | 550 parameters.codecs.push_back(codec); |
| 551 success = channel_->SetSendParameters(parameters); |
| 552 } |
| 553 if (success) { |
552 success = SetSend(sending); | 554 success = SetSend(sending); |
| 555 } |
553 return success; | 556 return success; |
554 } | 557 } |
555 bool SetSend(bool send) { | 558 bool SetSend(bool send) { |
556 return channel_->SetSend(send); | 559 return channel_->SetSend(send); |
557 } | 560 } |
558 bool SetSendStreamFormat(uint32 ssrc, const cricket::VideoCodec& codec) { | 561 bool SetSendStreamFormat(uint32 ssrc, const cricket::VideoCodec& codec) { |
559 return channel_->SetSendStreamFormat(ssrc, cricket::VideoFormat( | 562 return channel_->SetSendStreamFormat(ssrc, cricket::VideoFormat( |
560 codec.width, codec.height, | 563 codec.width, codec.height, |
561 cricket::VideoFormat::FpsToInterval(codec.framerate), | 564 cricket::VideoFormat::FpsToInterval(codec.framerate), |
562 cricket::FOURCC_ANY)); | 565 cricket::FOURCC_ANY)); |
(...skipping 290 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
853 EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width); | 856 EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width); |
854 EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height); | 857 EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height); |
855 EXPECT_GT(info.receivers[0].framerate_rcvd, 0); | 858 EXPECT_GT(info.receivers[0].framerate_rcvd, 0); |
856 EXPECT_GT(info.receivers[0].framerate_decoded, 0); | 859 EXPECT_GT(info.receivers[0].framerate_decoded, 0); |
857 EXPECT_GT(info.receivers[0].framerate_output, 0); | 860 EXPECT_GT(info.receivers[0].framerate_output, 0); |
858 } | 861 } |
859 // Test that stats work properly for a conf call with multiple recv streams. | 862 // Test that stats work properly for a conf call with multiple recv streams. |
860 void GetStatsMultipleRecvStreams() { | 863 void GetStatsMultipleRecvStreams() { |
861 cricket::FakeVideoRenderer renderer1, renderer2; | 864 cricket::FakeVideoRenderer renderer1, renderer2; |
862 EXPECT_TRUE(SetOneCodec(DefaultCodec())); | 865 EXPECT_TRUE(SetOneCodec(DefaultCodec())); |
863 cricket::VideoOptions vmo; | 866 cricket::VideoSendParameters parameters; |
864 vmo.conference_mode.Set(true); | 867 parameters.codecs.push_back(DefaultCodec()); |
865 EXPECT_TRUE(channel_->SetOptions(vmo)); | 868 parameters.options.conference_mode.Set(true); |
| 869 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
866 EXPECT_TRUE(SetSend(true)); | 870 EXPECT_TRUE(SetSend(true)); |
867 EXPECT_TRUE(channel_->AddRecvStream( | 871 EXPECT_TRUE(channel_->AddRecvStream( |
868 cricket::StreamParams::CreateLegacy(1))); | 872 cricket::StreamParams::CreateLegacy(1))); |
869 EXPECT_TRUE(channel_->AddRecvStream( | 873 EXPECT_TRUE(channel_->AddRecvStream( |
870 cricket::StreamParams::CreateLegacy(2))); | 874 cricket::StreamParams::CreateLegacy(2))); |
871 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1)); | 875 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1)); |
872 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2)); | 876 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2)); |
873 EXPECT_TRUE(channel_->SetRender(true)); | 877 EXPECT_TRUE(channel_->SetRender(true)); |
874 EXPECT_EQ(0, renderer1.num_rendered_frames()); | 878 EXPECT_EQ(0, renderer1.num_rendered_frames()); |
875 EXPECT_EQ(0, renderer2.num_rendered_frames()); | 879 EXPECT_EQ(0, renderer2.num_rendered_frames()); |
(...skipping 25 matching lines...) Expand all Loading... |
901 EXPECT_EQ(NumRtpPackets(), info.receivers[i].packets_rcvd); | 905 EXPECT_EQ(NumRtpPackets(), info.receivers[i].packets_rcvd); |
902 EXPECT_EQ(DefaultCodec().width, info.receivers[i].frame_width); | 906 EXPECT_EQ(DefaultCodec().width, info.receivers[i].frame_width); |
903 EXPECT_EQ(DefaultCodec().height, info.receivers[i].frame_height); | 907 EXPECT_EQ(DefaultCodec().height, info.receivers[i].frame_height); |
904 } | 908 } |
905 } | 909 } |
906 // Test that stats work properly for a conf call with multiple send streams. | 910 // Test that stats work properly for a conf call with multiple send streams. |
907 void GetStatsMultipleSendStreams() { | 911 void GetStatsMultipleSendStreams() { |
908 // Normal setup; note that we set the SSRC explicitly to ensure that | 912 // Normal setup; note that we set the SSRC explicitly to ensure that |
909 // it will come first in the senders map. | 913 // it will come first in the senders map. |
910 EXPECT_TRUE(SetOneCodec(DefaultCodec())); | 914 EXPECT_TRUE(SetOneCodec(DefaultCodec())); |
911 cricket::VideoOptions vmo; | 915 cricket::VideoSendParameters parameters; |
912 vmo.conference_mode.Set(true); | 916 parameters.codecs.push_back(DefaultCodec()); |
913 EXPECT_TRUE(channel_->SetOptions(vmo)); | 917 parameters.options.conference_mode.Set(true); |
| 918 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
914 EXPECT_TRUE(channel_->AddRecvStream( | 919 EXPECT_TRUE(channel_->AddRecvStream( |
915 cricket::StreamParams::CreateLegacy(kSsrc))); | 920 cricket::StreamParams::CreateLegacy(kSsrc))); |
916 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_)); | 921 EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_)); |
917 channel_->UpdateAspectRatio(640, 400); | 922 channel_->UpdateAspectRatio(640, 400); |
918 EXPECT_TRUE(SetSend(true)); | 923 EXPECT_TRUE(SetSend(true)); |
919 EXPECT_TRUE(channel_->SetRender(true)); | 924 EXPECT_TRUE(channel_->SetRender(true)); |
920 EXPECT_TRUE(SendFrame()); | 925 EXPECT_TRUE(SendFrame()); |
921 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); | 926 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); |
922 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout); | 927 EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout); |
923 | 928 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
968 EXPECT_EQ(1U, info.senders[1].ssrcs().size()); | 973 EXPECT_EQ(1U, info.senders[1].ssrcs().size()); |
969 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]); | 974 EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]); |
970 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width); | 975 EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width); |
971 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height); | 976 EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height); |
972 // The capturer must be unregistered here as it runs out of it's scope next. | 977 // The capturer must be unregistered here as it runs out of it's scope next. |
973 EXPECT_TRUE(channel_->SetCapturer(5678, NULL)); | 978 EXPECT_TRUE(channel_->SetCapturer(5678, NULL)); |
974 } | 979 } |
975 | 980 |
976 // Test that we can set the bandwidth. | 981 // Test that we can set the bandwidth. |
977 void SetSendBandwidth() { | 982 void SetSendBandwidth() { |
978 EXPECT_TRUE(channel_->SetMaxSendBandwidth(-1)); // <= 0 means unlimited. | 983 cricket::VideoSendParameters parameters; |
979 EXPECT_TRUE(channel_->SetMaxSendBandwidth(128 * 1024)); | 984 parameters.codecs.push_back(DefaultCodec()); |
| 985 parameters.max_bandwidth_bps = -1; // <= 0 means unlimited. |
| 986 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 987 parameters.max_bandwidth_bps = 128 * 1024; |
| 988 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
980 } | 989 } |
981 // Test that we can set the SSRC for the default send source. | 990 // Test that we can set the SSRC for the default send source. |
982 void SetSendSsrc() { | 991 void SetSendSsrc() { |
983 EXPECT_TRUE(SetDefaultCodec()); | 992 EXPECT_TRUE(SetDefaultCodec()); |
984 EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec())); | 993 EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec())); |
985 EXPECT_TRUE(SetSend(true)); | 994 EXPECT_TRUE(SetSend(true)); |
986 EXPECT_TRUE(SendFrame()); | 995 EXPECT_TRUE(SendFrame()); |
987 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); | 996 EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout); |
988 uint32 ssrc = 0; | 997 uint32 ssrc = 0; |
989 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0)); | 998 rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0)); |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1075 // Wait 30ms to guarantee the engine does not drop the frame. | 1084 // Wait 30ms to guarantee the engine does not drop the frame. |
1076 EXPECT_TRUE(WaitAndSendFrame(30)); | 1085 EXPECT_TRUE(WaitAndSendFrame(30)); |
1077 EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout); | 1086 EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout); |
1078 | 1087 |
1079 last_packet = NumRtpPackets() - 1; | 1088 last_packet = NumRtpPackets() - 1; |
1080 p.reset(GetRtpPacket(static_cast<int>(last_packet))); | 1089 p.reset(GetRtpPacket(static_cast<int>(last_packet))); |
1081 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL); | 1090 ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL); |
1082 EXPECT_EQ(789u, ssrc); | 1091 EXPECT_EQ(789u, ssrc); |
1083 } | 1092 } |
1084 | 1093 |
1085 // Tests adding streams already exists returns false. | |
1086 void AddRecvStreamsAlreadyExist() { | |
1087 cricket::VideoOptions vmo; | |
1088 vmo.conference_mode.Set(true); | |
1089 EXPECT_TRUE(channel_->SetOptions(vmo)); | |
1090 | |
1091 EXPECT_FALSE(channel_->AddRecvStream( | |
1092 cricket::StreamParams::CreateLegacy(0))); | |
1093 | |
1094 EXPECT_TRUE(channel_->AddRecvStream( | |
1095 cricket::StreamParams::CreateLegacy(1))); | |
1096 EXPECT_FALSE(channel_->AddRecvStream( | |
1097 cricket::StreamParams::CreateLegacy(1))); | |
1098 | |
1099 EXPECT_TRUE(channel_->RemoveRecvStream(1)); | |
1100 EXPECT_FALSE(channel_->AddRecvStream( | |
1101 cricket::StreamParams::CreateLegacy(0))); | |
1102 EXPECT_TRUE(channel_->AddRecvStream( | |
1103 cricket::StreamParams::CreateLegacy(1))); | |
1104 } | |
1105 | |
1106 // Tests setting up and configuring multiple incoming streams. | 1094 // Tests setting up and configuring multiple incoming streams. |
1107 void AddRemoveRecvStreams() { | 1095 void AddRemoveRecvStreams() { |
1108 cricket::FakeVideoRenderer renderer1, renderer2; | 1096 cricket::FakeVideoRenderer renderer1, renderer2; |
1109 cricket::VideoOptions vmo; | 1097 cricket::VideoSendParameters parameters; |
1110 vmo.conference_mode.Set(true); | 1098 parameters.codecs.push_back(DefaultCodec()); |
1111 EXPECT_TRUE(channel_->SetOptions(vmo)); | 1099 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 1100 |
1112 // Ensure we can't set the renderer on a non-existent stream. | 1101 // Ensure we can't set the renderer on a non-existent stream. |
1113 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1)); | 1102 EXPECT_FALSE(channel_->SetRenderer(1, &renderer1)); |
1114 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2)); | 1103 EXPECT_FALSE(channel_->SetRenderer(2, &renderer2)); |
1115 cricket::VideoRenderer* renderer; | 1104 cricket::VideoRenderer* renderer; |
1116 EXPECT_FALSE(channel_->GetRenderer(1, &renderer)); | 1105 EXPECT_FALSE(channel_->GetRenderer(1, &renderer)); |
1117 EXPECT_FALSE(channel_->GetRenderer(2, &renderer)); | 1106 EXPECT_FALSE(channel_->GetRenderer(2, &renderer)); |
1118 | 1107 |
1119 // Ensure we can add streams. | 1108 // Ensure we can add streams. |
1120 EXPECT_TRUE(channel_->AddRecvStream( | 1109 EXPECT_TRUE(channel_->AddRecvStream( |
1121 cricket::StreamParams::CreateLegacy(1))); | 1110 cricket::StreamParams::CreateLegacy(1))); |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1231 EXPECT_GT_FRAME_ON_RENDERER_WAIT( | 1220 EXPECT_GT_FRAME_ON_RENDERER_WAIT( |
1232 renderer1, 2, DefaultCodec().width, DefaultCodec().height, kTimeout); | 1221 renderer1, 2, DefaultCodec().width, DefaultCodec().height, kTimeout); |
1233 // Detach |renderer1| before exit as there might be frames come late. | 1222 // Detach |renderer1| before exit as there might be frames come late. |
1234 EXPECT_TRUE(channel_->SetRenderer(kSsrc, NULL)); | 1223 EXPECT_TRUE(channel_->SetRenderer(kSsrc, NULL)); |
1235 } | 1224 } |
1236 | 1225 |
1237 // Tests the behavior of incoming streams in a conference scenario. | 1226 // Tests the behavior of incoming streams in a conference scenario. |
1238 void SimulateConference() { | 1227 void SimulateConference() { |
1239 cricket::FakeVideoRenderer renderer1, renderer2; | 1228 cricket::FakeVideoRenderer renderer1, renderer2; |
1240 EXPECT_TRUE(SetDefaultCodec()); | 1229 EXPECT_TRUE(SetDefaultCodec()); |
1241 cricket::VideoOptions vmo; | 1230 cricket::VideoSendParameters parameters; |
1242 vmo.conference_mode.Set(true); | 1231 parameters.codecs.push_back(DefaultCodec()); |
1243 EXPECT_TRUE(channel_->SetOptions(vmo)); | 1232 parameters.options.conference_mode.Set(true); |
| 1233 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1244 EXPECT_TRUE(SetSend(true)); | 1234 EXPECT_TRUE(SetSend(true)); |
1245 EXPECT_TRUE(channel_->SetRender(true)); | 1235 EXPECT_TRUE(channel_->SetRender(true)); |
1246 EXPECT_TRUE(channel_->AddRecvStream( | 1236 EXPECT_TRUE(channel_->AddRecvStream( |
1247 cricket::StreamParams::CreateLegacy(1))); | 1237 cricket::StreamParams::CreateLegacy(1))); |
1248 EXPECT_TRUE(channel_->AddRecvStream( | 1238 EXPECT_TRUE(channel_->AddRecvStream( |
1249 cricket::StreamParams::CreateLegacy(2))); | 1239 cricket::StreamParams::CreateLegacy(2))); |
1250 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1)); | 1240 EXPECT_TRUE(channel_->SetRenderer(1, &renderer1)); |
1251 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2)); | 1241 EXPECT_TRUE(channel_->SetRenderer(2, &renderer2)); |
1252 EXPECT_EQ(0, renderer1.num_rendered_frames()); | 1242 EXPECT_EQ(0, renderer1.num_rendered_frames()); |
1253 EXPECT_EQ(0, renderer2.num_rendered_frames()); | 1243 EXPECT_EQ(0, renderer2.num_rendered_frames()); |
(...skipping 497 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1751 | 1741 |
1752 EXPECT_TRUE(channel_->SetCapturer(new_ssrc, video_capturer_.get())); | 1742 EXPECT_TRUE(channel_->SetCapturer(new_ssrc, video_capturer_.get())); |
1753 | 1743 |
1754 SendAndReceive(codec); | 1744 SendAndReceive(codec); |
1755 EXPECT_TRUE(channel_->RemoveSendStream(new_ssrc)); | 1745 EXPECT_TRUE(channel_->RemoveSendStream(new_ssrc)); |
1756 EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc()); | 1746 EXPECT_EQ(0u, channel_->GetDefaultSendChannelSsrc()); |
1757 } | 1747 } |
1758 | 1748 |
1759 // Tests that we can send and receive frames with early receive. | 1749 // Tests that we can send and receive frames with early receive. |
1760 void TwoStreamsSendAndUnsignalledRecv(const cricket::VideoCodec& codec) { | 1750 void TwoStreamsSendAndUnsignalledRecv(const cricket::VideoCodec& codec) { |
1761 cricket::VideoOptions vmo; | 1751 cricket::VideoSendParameters parameters; |
1762 vmo.conference_mode.Set(true); | 1752 parameters.options.conference_mode.Set(true); |
1763 vmo.unsignalled_recv_stream_limit.Set(1); | 1753 parameters.options.unsignalled_recv_stream_limit.Set(1); |
1764 EXPECT_TRUE(channel_->SetOptions(vmo)); | 1754 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1765 SetUpSecondStreamWithNoRecv(); | 1755 SetUpSecondStreamWithNoRecv(); |
1766 // Test sending and receiving on first stream. | 1756 // Test sending and receiving on first stream. |
1767 EXPECT_TRUE(channel_->SetRender(true)); | 1757 EXPECT_TRUE(channel_->SetRender(true)); |
1768 Send(codec); | 1758 Send(codec); |
1769 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout); | 1759 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout); |
1770 EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout); | 1760 EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout); |
1771 // The first send is not expected to yield frames, because the ssrc | 1761 // The first send is not expected to yield frames, because the ssrc |
1772 // is not signalled yet. With unsignalled recv enabled, we will drop frames | 1762 // is not signalled yet. With unsignalled recv enabled, we will drop frames |
1773 // instead of packets. | 1763 // instead of packets. |
1774 EXPECT_EQ(0, renderer2_.num_rendered_frames()); | 1764 EXPECT_EQ(0, renderer2_.num_rendered_frames()); |
1775 // Give a chance for the decoder to process before adding the receiver. | 1765 // Give a chance for the decoder to process before adding the receiver. |
1776 rtc::Thread::Current()->ProcessMessages(100); | 1766 rtc::Thread::Current()->ProcessMessages(100); |
1777 // Test sending and receiving on second stream. | 1767 // Test sending and receiving on second stream. |
1778 EXPECT_TRUE(channel_->AddRecvStream( | 1768 EXPECT_TRUE(channel_->AddRecvStream( |
1779 cricket::StreamParams::CreateLegacy(kSsrc + 2))); | 1769 cricket::StreamParams::CreateLegacy(kSsrc + 2))); |
1780 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_)); | 1770 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_)); |
1781 SendFrame(); | 1771 SendFrame(); |
1782 EXPECT_EQ_WAIT(2, renderer_.num_rendered_frames(), kTimeout); | 1772 EXPECT_EQ_WAIT(2, renderer_.num_rendered_frames(), kTimeout); |
1783 EXPECT_EQ(4, NumRtpPackets()); | 1773 EXPECT_EQ(4, NumRtpPackets()); |
1784 // The second send is expected to yield frame as the ssrc is signalled now. | 1774 // The second send is expected to yield frame as the ssrc is signalled now. |
1785 // Decode should succeed here, though we received the key frame earlier. | 1775 // Decode should succeed here, though we received the key frame earlier. |
1786 // Without early recv, we would have dropped it and decoding would have | 1776 // Without early recv, we would have dropped it and decoding would have |
1787 // failed. | 1777 // failed. |
1788 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout); | 1778 EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout); |
1789 } | 1779 } |
1790 | 1780 |
1791 // Tests that we cannot receive key frames with unsignalled recv disabled. | |
1792 void TwoStreamsSendAndFailUnsignalledRecv(const cricket::VideoCodec& codec) { | |
1793 cricket::VideoOptions vmo; | |
1794 vmo.conference_mode.Set(true); | |
1795 vmo.unsignalled_recv_stream_limit.Set(0); | |
1796 EXPECT_TRUE(channel_->SetOptions(vmo)); | |
1797 SetUpSecondStreamWithNoRecv(); | |
1798 // Test sending and receiving on first stream. | |
1799 EXPECT_TRUE(channel_->SetRender(true)); | |
1800 Send(codec); | |
1801 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout); | |
1802 rtc::Thread::Current()->ProcessMessages(100); | |
1803 EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout); | |
1804 EXPECT_EQ_WAIT(0, renderer2_.num_rendered_frames(), kTimeout); | |
1805 // Give a chance for the decoder to process before adding the receiver. | |
1806 rtc::Thread::Current()->ProcessMessages(10); | |
1807 // Test sending and receiving on second stream. | |
1808 EXPECT_TRUE(channel_->AddRecvStream( | |
1809 cricket::StreamParams::CreateLegacy(kSsrc + 2))); | |
1810 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_)); | |
1811 SendFrame(); | |
1812 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= 1, kTimeout); | |
1813 EXPECT_EQ_WAIT(4, NumRtpPackets(), kTimeout); | |
1814 // We dont expect any frames here, because the key frame would have been | |
1815 // lost in the earlier packet. This is the case we want to solve with early | |
1816 // receive. | |
1817 EXPECT_EQ(0, renderer2_.num_rendered_frames()); | |
1818 } | |
1819 | |
1820 // Tests that we drop key frames when conference mode is disabled and we | |
1821 // receive rtp packets on unsignalled streams. | |
1822 void TwoStreamsSendAndFailUnsignalledRecvInOneToOne( | |
1823 const cricket::VideoCodec& codec) { | |
1824 cricket::VideoOptions vmo; | |
1825 vmo.conference_mode.Set(false); | |
1826 vmo.unsignalled_recv_stream_limit.Set(1); | |
1827 EXPECT_TRUE(channel_->SetOptions(vmo)); | |
1828 SetUpSecondStreamWithNoRecv(); | |
1829 // Test sending and receiving on first stream. | |
1830 EXPECT_TRUE(channel_->SetRender(true)); | |
1831 Send(codec); | |
1832 EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout); | |
1833 // In one-to-one mode, we deliver frames to the default channel if there | |
1834 // is no registered recv channel for the ssrc. | |
1835 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= 1, kTimeout); | |
1836 // Give a chance for the decoder to process before adding the receiver. | |
1837 rtc::Thread::Current()->ProcessMessages(100); | |
1838 // Test sending and receiving on second stream. | |
1839 EXPECT_TRUE(channel_->AddRecvStream( | |
1840 cricket::StreamParams::CreateLegacy(kSsrc + 2))); | |
1841 EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_)); | |
1842 SendFrame(); | |
1843 EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= 1, kTimeout); | |
1844 EXPECT_EQ_WAIT(4, NumRtpPackets(), kTimeout); | |
1845 // We dont expect any frames here, because the key frame would have been | |
1846 // delivered to default channel. | |
1847 EXPECT_EQ(0, renderer2_.num_rendered_frames()); | |
1848 } | |
1849 | |
1850 // Tests that we drop key frames when conference mode is enabled and we | 1781 // Tests that we drop key frames when conference mode is enabled and we |
1851 // receive rtp packets on unsignalled streams. Removal of a unsignalled recv | 1782 // receive rtp packets on unsignalled streams. Removal of a unsignalled recv |
1852 // stream is successful. | 1783 // stream is successful. |
1853 void TwoStreamsAddAndRemoveUnsignalledRecv( | 1784 void TwoStreamsAddAndRemoveUnsignalledRecv( |
1854 const cricket::VideoCodec& codec) { | 1785 const cricket::VideoCodec& codec) { |
1855 cricket::VideoOptions vmo; | 1786 cricket::VideoOptions vmo; |
1856 vmo.conference_mode.Set(true); | 1787 vmo.conference_mode.Set(true); |
1857 vmo.unsignalled_recv_stream_limit.Set(1); | 1788 vmo.unsignalled_recv_stream_limit.Set(1); |
1858 EXPECT_TRUE(channel_->SetOptions(vmo)); | 1789 EXPECT_TRUE(channel_->SetOptions(vmo)); |
1859 SetUpSecondStreamWithNoRecv(); | 1790 SetUpSecondStreamWithNoRecv(); |
(...skipping 20 matching lines...) Expand all Loading... |
1880 rtc::scoped_ptr<C> channel_; | 1811 rtc::scoped_ptr<C> channel_; |
1881 cricket::FakeNetworkInterface network_interface_; | 1812 cricket::FakeNetworkInterface network_interface_; |
1882 cricket::FakeVideoRenderer renderer_; | 1813 cricket::FakeVideoRenderer renderer_; |
1883 cricket::VideoMediaChannel::Error media_error_; | 1814 cricket::VideoMediaChannel::Error media_error_; |
1884 | 1815 |
1885 // Used by test cases where 2 streams are run on the same channel. | 1816 // Used by test cases where 2 streams are run on the same channel. |
1886 cricket::FakeVideoRenderer renderer2_; | 1817 cricket::FakeVideoRenderer renderer2_; |
1887 }; | 1818 }; |
1888 | 1819 |
1889 #endif // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT | 1820 #endif // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_ NOLINT |
OLD | NEW |