OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2004 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 |
(...skipping 1986 matching lines...) Loading... |
1997 AddSendStream(); | 1997 AddSendStream(); |
1998 | 1998 |
1999 cricket::FakeVideoCapturer capturer; | 1999 cricket::FakeVideoCapturer capturer; |
2000 ASSERT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 2000 ASSERT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
2001 ASSERT_EQ(cricket::CS_RUNNING, | 2001 ASSERT_EQ(cricket::CS_RUNNING, |
2002 capturer.Start(capturer.GetSupportedFormats()->front())); | 2002 capturer.Start(capturer.GetSupportedFormats()->front())); |
2003 ASSERT_TRUE(channel_->SetSend(true)); | 2003 ASSERT_TRUE(channel_->SetSend(true)); |
2004 | 2004 |
2005 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); | 2005 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
2006 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); | 2006 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
2007 webrtc::LoadObserver* overuse_callback = | |
2008 send_stream->GetConfig().overuse_callback; | |
2009 ASSERT_TRUE(overuse_callback != NULL); | |
2010 | 2007 |
2011 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2008 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2012 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); | 2009 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
2013 EXPECT_EQ(1280, send_stream->GetLastWidth()); | 2010 EXPECT_EQ(1280, send_stream->GetLastWidth()); |
2014 EXPECT_EQ(720, send_stream->GetLastHeight()); | 2011 EXPECT_EQ(720, send_stream->GetLastHeight()); |
2015 | 2012 |
2016 // Trigger overuse. | 2013 // Trigger overuse. |
2017 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | 2014 rtc::VideoSinkWants wants; |
| 2015 wants.max_pixel_count = rtc::Optional<int>( |
| 2016 send_stream->GetLastWidth() * send_stream->GetLastHeight() - 1); |
| 2017 send_stream->InjectVideoSinkWants(wants); |
2018 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2018 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2019 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); | 2019 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); |
2020 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); | 2020 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); |
2021 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); | 2021 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); |
2022 | 2022 |
2023 // Trigger overuse again. | 2023 // Trigger overuse again. |
2024 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | 2024 wants.max_pixel_count = rtc::Optional<int>( |
| 2025 send_stream->GetLastWidth() * send_stream->GetLastHeight() - 1); |
| 2026 send_stream->InjectVideoSinkWants(wants); |
2025 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2027 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2026 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames()); | 2028 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames()); |
2027 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth()); | 2029 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth()); |
2028 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight()); | 2030 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight()); |
2029 | 2031 |
2030 // Trigger overuse again. This should not decrease the resolution since we | |
2031 // should only adapt the resolution down max two steps. | |
2032 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | |
2033 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | |
2034 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); | |
2035 EXPECT_EQ(1280 * 2 / 4, send_stream->GetLastWidth()); | |
2036 EXPECT_EQ(720 * 2 / 4, send_stream->GetLastHeight()); | |
2037 | |
2038 // Change input resolution. | 2032 // Change input resolution. |
2039 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); | 2033 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); |
2040 EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames()); | 2034 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); |
2041 EXPECT_EQ(1284 / 2, send_stream->GetLastWidth()); | 2035 EXPECT_EQ(1284 / 2, send_stream->GetLastWidth()); |
2042 EXPECT_EQ(724 / 2, send_stream->GetLastHeight()); | 2036 EXPECT_EQ(724 / 2, send_stream->GetLastHeight()); |
2043 | 2037 |
2044 // Trigger underuse which should go back up in resolution. | 2038 // Trigger underuse which should go back up in resolution. |
2045 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); | 2039 wants.max_pixel_count = rtc::Optional<int>(); |
| 2040 wants.max_pixel_count_step_up = rtc::Optional<int>( |
| 2041 send_stream->GetLastWidth() * send_stream->GetLastHeight()); |
| 2042 send_stream->InjectVideoSinkWants(wants); |
2046 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); | 2043 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); |
2047 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames()); | 2044 EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames()); |
2048 EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth()); | 2045 EXPECT_EQ(1284 * 3 / 4, send_stream->GetLastWidth()); |
2049 EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight()); | 2046 EXPECT_EQ(724 * 3 / 4, send_stream->GetLastHeight()); |
2050 | 2047 |
2051 // Trigger underuse which should go back up in resolution. | 2048 // Trigger underuse which should go back up in resolution. |
2052 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); | 2049 wants.max_pixel_count = rtc::Optional<int>(); |
| 2050 wants.max_pixel_count_step_up = rtc::Optional<int>( |
| 2051 send_stream->GetLastWidth() * send_stream->GetLastHeight()); |
| 2052 send_stream->InjectVideoSinkWants(wants); |
2053 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); | 2053 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); |
2054 EXPECT_EQ(7, send_stream->GetNumberOfSwappedFrames()); | 2054 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames()); |
2055 EXPECT_EQ(1284, send_stream->GetLastWidth()); | 2055 EXPECT_EQ(1284, send_stream->GetLastWidth()); |
2056 EXPECT_EQ(724, send_stream->GetLastHeight()); | 2056 EXPECT_EQ(724, send_stream->GetLastHeight()); |
2057 | 2057 |
2058 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2058 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2059 } | 2059 } |
2060 | 2060 |
2061 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { | 2061 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { |
2062 cricket::VideoCodec codec = kVp8Codec720p; | 2062 cricket::VideoCodec codec = kVp8Codec720p; |
2063 cricket::VideoSendParameters parameters; | 2063 cricket::VideoSendParameters parameters; |
2064 parameters.codecs.push_back(codec); | 2064 parameters.codecs.push_back(codec); |
2065 | 2065 |
2066 MediaConfig media_config = MediaConfig(); | 2066 MediaConfig media_config = MediaConfig(); |
2067 channel_.reset( | 2067 channel_.reset( |
2068 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); | 2068 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); |
2069 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2069 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2070 | 2070 |
2071 AddSendStream(); | 2071 AddSendStream(); |
2072 | 2072 |
2073 cricket::FakeVideoCapturer capturer; | 2073 cricket::FakeVideoCapturer capturer; |
2074 ASSERT_EQ(cricket::CS_RUNNING, | 2074 ASSERT_EQ(cricket::CS_RUNNING, |
2075 capturer.Start(capturer.GetSupportedFormats()->front())); | 2075 capturer.Start(capturer.GetSupportedFormats()->front())); |
2076 ASSERT_TRUE(channel_->SetSend(true)); | 2076 ASSERT_TRUE(channel_->SetSend(true)); |
2077 cricket::VideoOptions camera_options; | 2077 cricket::VideoOptions camera_options; |
| 2078 camera_options.is_screencast = rtc::Optional<bool>(false); |
2078 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options, | 2079 channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options, |
2079 &capturer); | 2080 &capturer); |
2080 | 2081 |
2081 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); | 2082 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
2082 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); | 2083 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
2083 webrtc::LoadObserver* overuse_callback = | |
2084 send_stream->GetConfig().overuse_callback; | |
2085 ASSERT_TRUE(overuse_callback != NULL); | |
2086 | 2084 |
2087 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2085 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2088 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); | 2086 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
2089 EXPECT_EQ(1280, send_stream->GetLastWidth()); | 2087 EXPECT_EQ(1280, send_stream->GetLastWidth()); |
2090 EXPECT_EQ(720, send_stream->GetLastHeight()); | 2088 EXPECT_EQ(720, send_stream->GetLastHeight()); |
2091 | 2089 |
2092 // Trigger overuse. | 2090 // Trigger overuse. |
2093 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | 2091 rtc::VideoSinkWants wants; |
| 2092 wants.max_pixel_count = rtc::Optional<int>( |
| 2093 send_stream->GetLastWidth() * send_stream->GetLastHeight() - 1); |
| 2094 send_stream->InjectVideoSinkWants(wants); |
2094 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2095 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2095 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); | 2096 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); |
2096 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); | 2097 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); |
2097 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); | 2098 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); |
2098 | 2099 |
2099 // Switch to screen share. Expect no CPU adaptation. | 2100 // Switch to screen share. Expect no CPU adaptation. |
2100 cricket::FakeVideoCapturer screen_share(true); | 2101 cricket::FakeVideoCapturer screen_share(true); |
2101 ASSERT_EQ(cricket::CS_RUNNING, | 2102 ASSERT_EQ(cricket::CS_RUNNING, |
2102 screen_share.Start(screen_share.GetSupportedFormats()->front())); | 2103 screen_share.Start(screen_share.GetSupportedFormats()->front())); |
2103 cricket::VideoOptions screenshare_options; | 2104 cricket::VideoOptions screenshare_options; |
(...skipping 35 matching lines...) Loading... |
2139 | 2140 |
2140 cricket::FakeVideoCapturer capturer; | 2141 cricket::FakeVideoCapturer capturer; |
2141 VideoOptions options; | 2142 VideoOptions options; |
2142 options.is_screencast = rtc::Optional<bool>(is_screenshare); | 2143 options.is_screencast = rtc::Optional<bool>(is_screenshare); |
2143 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); | 2144 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); |
2144 EXPECT_EQ(cricket::CS_RUNNING, | 2145 EXPECT_EQ(cricket::CS_RUNNING, |
2145 capturer.Start(capturer.GetSupportedFormats()->front())); | 2146 capturer.Start(capturer.GetSupportedFormats()->front())); |
2146 | 2147 |
2147 EXPECT_TRUE(channel_->SetSend(true)); | 2148 EXPECT_TRUE(channel_->SetSend(true)); |
2148 | 2149 |
2149 // Trigger overuse. | |
2150 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); | |
2151 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); | 2150 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
2152 webrtc::LoadObserver* overuse_callback = | |
2153 send_stream->GetConfig().overuse_callback; | |
2154 | 2151 |
2155 if (!enable_overuse) { | 2152 if (!enable_overuse || is_screenshare) { |
2156 ASSERT_TRUE(overuse_callback == NULL); | 2153 EXPECT_TRUE(send_stream->resolution_scaling_disabled()); |
2157 | 2154 |
2158 EXPECT_TRUE(capturer.CaptureFrame()); | 2155 EXPECT_TRUE(capturer.CaptureFrame()); |
2159 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); | 2156 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
2160 | 2157 |
2161 EXPECT_EQ(codec.width, send_stream->GetLastWidth()); | 2158 EXPECT_EQ(codec.width, send_stream->GetLastWidth()); |
2162 EXPECT_EQ(codec.height, send_stream->GetLastHeight()); | 2159 EXPECT_EQ(codec.height, send_stream->GetLastHeight()); |
2163 | 2160 |
2164 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2161 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2165 return; | 2162 return; |
2166 } | 2163 } |
2167 | 2164 |
2168 ASSERT_TRUE(overuse_callback != NULL); | 2165 EXPECT_FALSE(send_stream->resolution_scaling_disabled()); |
| 2166 // Trigger overuse. |
| 2167 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
| 2168 |
| 2169 rtc::VideoSinkWants wants; |
| 2170 wants.max_pixel_count = rtc::Optional<int>(codec.width * codec.height - 1); |
| 2171 send_stream->InjectVideoSinkWants(wants); |
| 2172 |
2169 EXPECT_TRUE(capturer.CaptureFrame()); | 2173 EXPECT_TRUE(capturer.CaptureFrame()); |
2170 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); | 2174 EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); |
2171 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | |
2172 | 2175 |
2173 EXPECT_TRUE(capturer.CaptureFrame()); | 2176 EXPECT_TRUE(capturer.CaptureFrame()); |
2174 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); | 2177 EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); |
2175 | 2178 |
2176 if (is_screenshare) { | 2179 EXPECT_LT(send_stream->GetLastWidth(), codec.width); |
2177 // Do not adapt screen share. | 2180 EXPECT_LT(send_stream->GetLastHeight(), codec.height); |
2178 EXPECT_EQ(codec.width, send_stream->GetLastWidth()); | |
2179 EXPECT_EQ(codec.height, send_stream->GetLastHeight()); | |
2180 } else { | |
2181 EXPECT_LT(send_stream->GetLastWidth(), codec.width); | |
2182 EXPECT_LT(send_stream->GetLastHeight(), codec.height); | |
2183 } | |
2184 | 2181 |
2185 // Trigger underuse which should go back to normal resolution. | 2182 // Trigger underuse which should go back to normal resolution. |
2186 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); | 2183 wants.max_pixel_count = rtc::Optional<int>(); |
| 2184 wants.max_pixel_count_step_up = rtc::Optional<int>( |
| 2185 send_stream->GetLastWidth() * send_stream->GetLastHeight()); |
| 2186 send_stream->InjectVideoSinkWants(wants); |
| 2187 |
2187 EXPECT_TRUE(capturer.CaptureFrame()); | 2188 EXPECT_TRUE(capturer.CaptureFrame()); |
2188 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames()); | 2189 EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames()); |
2189 | 2190 |
2190 EXPECT_EQ(codec.width, send_stream->GetLastWidth()); | 2191 EXPECT_EQ(codec.width, send_stream->GetLastWidth()); |
2191 EXPECT_EQ(codec.height, send_stream->GetLastHeight()); | 2192 EXPECT_EQ(codec.height, send_stream->GetLastHeight()); |
2192 | 2193 |
2193 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2194 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2194 } | 2195 } |
2195 | 2196 |
2196 TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) { | 2197 TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) { |
(...skipping 718 matching lines...) Loading... |
2915 webrtc::VideoSendStream::Stats stats; | 2916 webrtc::VideoSendStream::Stats stats; |
2916 stats.preferred_media_bitrate_bps = 5; | 2917 stats.preferred_media_bitrate_bps = 5; |
2917 stream->SetStats(stats); | 2918 stream->SetStats(stats); |
2918 | 2919 |
2919 cricket::VideoMediaInfo info; | 2920 cricket::VideoMediaInfo info; |
2920 ASSERT_TRUE(channel_->GetStats(&info)); | 2921 ASSERT_TRUE(channel_->GetStats(&info)); |
2921 ASSERT_EQ(1u, info.senders.size()); | 2922 ASSERT_EQ(1u, info.senders.size()); |
2922 EXPECT_EQ(5, info.senders[0].preferred_bitrate); | 2923 EXPECT_EQ(5, info.senders[0].preferred_bitrate); |
2923 } | 2924 } |
2924 | 2925 |
2925 TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) { | 2926 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuAdaptationStats) { |
2926 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); | 2927 FakeVideoSendStream* stream = AddSendStream(); |
| 2928 webrtc::VideoSendStream::Stats stats; |
| 2929 stats.number_of_cpu_adapt_changes = 2; |
| 2930 stats.cpu_limited_resolution = true; |
| 2931 stream->SetStats(stats); |
2927 | 2932 |
2928 // Capture format VGA. | |
2929 cricket::FakeVideoCapturer video_capturer_vga; | |
2930 const std::vector<cricket::VideoFormat>* formats = | |
2931 video_capturer_vga.GetSupportedFormats(); | |
2932 cricket::VideoFormat capture_format_vga = (*formats)[1]; | |
2933 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga)); | |
2934 EXPECT_TRUE( | |
2935 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_vga)); | |
2936 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
2937 | |
2938 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30); | |
2939 cricket::VideoSendParameters parameters; | |
2940 parameters.codecs.push_back(send_codec); | |
2941 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
2942 EXPECT_TRUE(channel_->SetSend(true)); | |
2943 | |
2944 // Verify that the CpuOveruseObserver is registered and trigger downgrade. | |
2945 | |
2946 // Trigger overuse. | |
2947 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); | |
2948 webrtc::LoadObserver* overuse_callback = | |
2949 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback; | |
2950 ASSERT_TRUE(overuse_callback != NULL); | |
2951 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | |
2952 | |
2953 // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2. | |
2954 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
2955 cricket::VideoMediaInfo info; | |
2956 EXPECT_TRUE(channel_->GetStats(&info)); | |
2957 ASSERT_EQ(1U, info.senders.size()); | |
2958 EXPECT_EQ(1, info.senders[0].adapt_changes); | |
2959 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason); | |
2960 | |
2961 // Trigger upgrade and verify that we adapt back up to VGA. | |
2962 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); | |
2963 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
2964 info.Clear(); | |
2965 EXPECT_TRUE(channel_->GetStats(&info)); | |
2966 ASSERT_EQ(1U, info.senders.size()); | |
2967 EXPECT_EQ(2, info.senders[0].adapt_changes); | |
2968 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE, | |
2969 info.senders[0].adapt_reason); | |
2970 | |
2971 // No capturer (no adapter). Adapt changes from old adapter should be kept. | |
2972 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); | |
2973 info.Clear(); | |
2974 EXPECT_TRUE(channel_->GetStats(&info)); | |
2975 ASSERT_EQ(1U, info.senders.size()); | |
2976 EXPECT_EQ(2, info.senders[0].adapt_changes); | |
2977 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE, | |
2978 info.senders[0].adapt_reason); | |
2979 | |
2980 // Set new capturer, capture format HD. | |
2981 cricket::FakeVideoCapturer video_capturer_hd; | |
2982 cricket::VideoFormat capture_format_hd = (*formats)[0]; | |
2983 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_hd.Start(capture_format_hd)); | |
2984 EXPECT_TRUE( | |
2985 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_hd)); | |
2986 EXPECT_TRUE(video_capturer_hd.CaptureFrame()); | |
2987 | |
2988 // Trigger overuse, HD -> adapt (OnCpuResolutionRequest downgrade) -> HD/2. | |
2989 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | |
2990 EXPECT_TRUE(video_capturer_hd.CaptureFrame()); | |
2991 info.Clear(); | |
2992 EXPECT_TRUE(channel_->GetStats(&info)); | |
2993 ASSERT_EQ(1U, info.senders.size()); | |
2994 EXPECT_EQ(3, info.senders[0].adapt_changes); | |
2995 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason); | |
2996 | |
2997 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); | |
2998 } | |
2999 | |
3000 TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationAndBandwidthStats) { | |
3001 AddSendStream(cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); | |
3002 | |
3003 // Capture format VGA. | |
3004 cricket::FakeVideoCapturer video_capturer_vga; | |
3005 const std::vector<cricket::VideoFormat>* formats = | |
3006 video_capturer_vga.GetSupportedFormats(); | |
3007 cricket::VideoFormat capture_format_vga = (*formats)[1]; | |
3008 EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga)); | |
3009 EXPECT_TRUE( | |
3010 channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &video_capturer_vga)); | |
3011 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
3012 | |
3013 cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30); | |
3014 cricket::VideoSendParameters parameters; | |
3015 parameters.codecs.push_back(send_codec); | |
3016 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | |
3017 EXPECT_TRUE(channel_->SetSend(true)); | |
3018 | |
3019 // Verify that the CpuOveruseObserver is registered and trigger downgrade. | |
3020 | |
3021 // Trigger overuse -> adapt CPU. | |
3022 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); | |
3023 webrtc::LoadObserver* overuse_callback = | |
3024 fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback; | |
3025 ASSERT_TRUE(overuse_callback != NULL); | |
3026 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse); | |
3027 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
3028 cricket::VideoMediaInfo info; | 2933 cricket::VideoMediaInfo info; |
3029 EXPECT_TRUE(channel_->GetStats(&info)); | 2934 EXPECT_TRUE(channel_->GetStats(&info)); |
3030 ASSERT_EQ(1U, info.senders.size()); | 2935 ASSERT_EQ(1U, info.senders.size()); |
3031 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason); | 2936 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU, info.senders[0].adapt_reason); |
| 2937 EXPECT_EQ(2, info.senders[0].adapt_changes); |
| 2938 } |
3032 | 2939 |
3033 // Set bandwidth limitation stats for the stream -> adapt CPU + BW. | 2940 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsAdaptationAndBandwidthStats) { |
| 2941 FakeVideoSendStream* stream = AddSendStream(); |
3034 webrtc::VideoSendStream::Stats stats; | 2942 webrtc::VideoSendStream::Stats stats; |
| 2943 stats.number_of_cpu_adapt_changes = 2; |
| 2944 stats.cpu_limited_resolution = true; |
3035 stats.bw_limited_resolution = true; | 2945 stats.bw_limited_resolution = true; |
3036 fake_call_->GetVideoSendStreams().front()->SetStats(stats); | 2946 stream->SetStats(stats); |
3037 info.Clear(); | 2947 |
| 2948 cricket::VideoMediaInfo info; |
3038 EXPECT_TRUE(channel_->GetStats(&info)); | 2949 EXPECT_TRUE(channel_->GetStats(&info)); |
3039 ASSERT_EQ(1U, info.senders.size()); | 2950 ASSERT_EQ(1U, info.senders.size()); |
3040 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU | | 2951 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_CPU | |
3041 WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH, | 2952 WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH, |
3042 info.senders[0].adapt_reason); | 2953 info.senders[0].adapt_reason); |
3043 | 2954 EXPECT_EQ(2, info.senders[0].adapt_changes); |
3044 // Trigger upgrade -> adapt BW. | |
3045 overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kUnderuse); | |
3046 EXPECT_TRUE(video_capturer_vga.CaptureFrame()); | |
3047 info.Clear(); | |
3048 EXPECT_TRUE(channel_->GetStats(&info)); | |
3049 ASSERT_EQ(1U, info.senders.size()); | |
3050 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_BANDWIDTH, | |
3051 info.senders[0].adapt_reason); | |
3052 | |
3053 // Reset bandwidth limitation state -> adapt NONE. | |
3054 stats.bw_limited_resolution = false; | |
3055 fake_call_->GetVideoSendStreams().front()->SetStats(stats); | |
3056 info.Clear(); | |
3057 EXPECT_TRUE(channel_->GetStats(&info)); | |
3058 ASSERT_EQ(1U, info.senders.size()); | |
3059 EXPECT_EQ(WebRtcVideoChannel2::ADAPTREASON_NONE, | |
3060 info.senders[0].adapt_reason); | |
3061 | |
3062 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); | |
3063 } | 2955 } |
3064 | 2956 |
3065 TEST_F(WebRtcVideoChannel2Test, | 2957 TEST_F(WebRtcVideoChannel2Test, |
3066 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) { | 2958 GetStatsTranslatesBandwidthLimitedResolutionCorrectly) { |
3067 FakeVideoSendStream* stream = AddSendStream(); | 2959 FakeVideoSendStream* stream = AddSendStream(); |
3068 webrtc::VideoSendStream::Stats stats; | 2960 webrtc::VideoSendStream::Stats stats; |
3069 stats.bw_limited_resolution = true; | 2961 stats.bw_limited_resolution = true; |
3070 stream->SetStats(stats); | 2962 stream->SetStats(stats); |
3071 | 2963 |
3072 cricket::VideoMediaInfo info; | 2964 cricket::VideoMediaInfo info; |
(...skipping 779 matching lines...) Loading... |
3852 } | 3744 } |
3853 | 3745 |
3854 // Test that we normalize send codec format size in simulcast. | 3746 // Test that we normalize send codec format size in simulcast. |
3855 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { | 3747 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { |
3856 cricket::VideoCodec codec(kVp8Codec270p); | 3748 cricket::VideoCodec codec(kVp8Codec270p); |
3857 codec.width += 1; | 3749 codec.width += 1; |
3858 codec.height += 1; | 3750 codec.height += 1; |
3859 VerifySimulcastSettings(codec, 2, 2); | 3751 VerifySimulcastSettings(codec, 2, 2); |
3860 } | 3752 } |
3861 } // namespace cricket | 3753 } // namespace cricket |
OLD | NEW |