Chromium Code Reviews

Side by Side Diff: webrtc/media/engine/webrtcvideoengine2_unittest.cc

Issue 2304363002: Let ViEEncoder express resolution requests as Sinkwants (Closed)
Patch Set: Rebased and fixed. Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View unified diff |
OLDNEW
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...)
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...)
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...)
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...)
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
OLDNEW

Powered by Google App Engine