OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/media_stream_constraints_util_video_content.h" | 5 #include "content/renderer/media/media_stream_constraints_util_video_content.h" |
6 | 6 |
7 #include <cmath> | 7 #include <cmath> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "content/renderer/media/media_stream_video_source.h" | |
11 #include "content/renderer/media/mock_constraint_factory.h" | 10 #include "content/renderer/media/mock_constraint_factory.h" |
| 11 #include "media/base/limits.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 #include "third_party/WebKit/public/platform/WebMediaConstraints.h" | 13 #include "third_party/WebKit/public/platform/WebMediaConstraints.h" |
14 | 14 |
15 namespace content { | 15 namespace content { |
16 | 16 |
17 namespace { | 17 namespace { |
18 | 18 |
19 void CheckNonResolutionDefaults( | 19 const double kDefaultScreenCastAspectRatio = |
20 const VideoContentCaptureSourceSelectionResult& result) { | 20 static_cast<double>(kDefaultScreenCastWidth) / |
21 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 21 static_cast<double>(kDefaultScreenCastHeight); |
22 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 22 |
| 23 void CheckNonResolutionDefaults(const VideoCaptureSettings& result) { |
| 24 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
| 25 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
23 EXPECT_EQ(std::string(), result.device_id()); | 26 EXPECT_EQ(std::string(), result.device_id()); |
24 } | 27 } |
25 | 28 |
26 void CheckNonFrameRateDefaults( | 29 void CheckNonFrameRateDefaults(const VideoCaptureSettings& result) { |
27 const VideoContentCaptureSourceSelectionResult& result) { | 30 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
28 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 31 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
29 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 32 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
30 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | |
31 EXPECT_EQ(std::string(), result.device_id()); | 33 EXPECT_EQ(std::string(), result.device_id()); |
32 } | 34 } |
33 | 35 |
| 36 void CheckTrackAdapterSettingsEqualsFormat(const VideoCaptureSettings& result) { |
| 37 // For content capture, resolution and frame rate should always be the same |
| 38 // for source and track. |
| 39 EXPECT_EQ(result.Width(), result.track_adapter_settings().max_width); |
| 40 EXPECT_EQ(result.Height(), result.track_adapter_settings().max_height); |
| 41 EXPECT_EQ(0.0, result.track_adapter_settings().max_frame_rate); |
| 42 } |
| 43 |
| 44 void CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio( |
| 45 const VideoCaptureSettings& result) { |
| 46 EXPECT_EQ( |
| 47 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension, |
| 48 result.track_adapter_settings().min_aspect_ratio); |
| 49 EXPECT_EQ( |
| 50 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
| 51 result.track_adapter_settings().max_aspect_ratio); |
| 52 CheckTrackAdapterSettingsEqualsFormat(result); |
| 53 } |
| 54 |
34 } // namespace | 55 } // namespace |
35 | 56 |
36 class MediaStreamConstraintsUtilVideoContentTest : public testing::Test { | 57 class MediaStreamConstraintsUtilVideoContentTest : public testing::Test { |
37 protected: | 58 protected: |
38 VideoContentCaptureSourceSelectionResult SelectSettings() { | 59 VideoCaptureSettings SelectSettings() { |
39 blink::WebMediaConstraints constraints = | 60 blink::WebMediaConstraints constraints = |
40 constraint_factory_.CreateWebMediaConstraints(); | 61 constraint_factory_.CreateWebMediaConstraints(); |
41 return SelectVideoContentCaptureSourceSettings(constraints); | 62 return SelectSettingsVideoContentCapture(constraints); |
42 } | 63 } |
43 | 64 |
44 MockConstraintFactory constraint_factory_; | 65 MockConstraintFactory constraint_factory_; |
45 }; | 66 }; |
46 | 67 |
47 // The Unconstrained test checks the default selection criteria. | 68 // The Unconstrained test checks the default selection criteria. |
48 TEST_F(MediaStreamConstraintsUtilVideoContentTest, Unconstrained) { | 69 TEST_F(MediaStreamConstraintsUtilVideoContentTest, Unconstrained) { |
49 constraint_factory_.Reset(); | 70 constraint_factory_.Reset(); |
50 auto result = SelectSettings(); | 71 auto result = SelectSettings(); |
51 | 72 |
52 // All settings should have default values. | 73 // All settings should have default values. |
53 EXPECT_TRUE(result.HasValue()); | 74 EXPECT_TRUE(result.HasValue()); |
54 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 75 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
55 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 76 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
56 CheckNonResolutionDefaults(result); | 77 CheckNonResolutionDefaults(result); |
| 78 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
57 } | 79 } |
58 | 80 |
59 // The "Overconstrained" tests verify that failure of any single required | 81 // The "Overconstrained" tests verify that failure of any single required |
60 // constraint results in failure to select a candidate. | 82 // constraint results in failure to select a candidate. |
61 TEST_F(MediaStreamConstraintsUtilVideoContentTest, OverconstrainedOnHeight) { | 83 TEST_F(MediaStreamConstraintsUtilVideoContentTest, OverconstrainedOnHeight) { |
62 constraint_factory_.Reset(); | 84 constraint_factory_.Reset(); |
63 constraint_factory_.basic().height.setExact(123467890); | 85 constraint_factory_.basic().height.setExact(123467890); |
64 auto result = SelectSettings(); | 86 auto result = SelectSettings(); |
65 EXPECT_FALSE(result.HasValue()); | 87 EXPECT_FALSE(result.HasValue()); |
66 EXPECT_EQ(constraint_factory_.basic().height.name(), | 88 EXPECT_EQ(constraint_factory_.basic().height.name(), |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 // for each individual constraint in the basic constraint set. | 177 // for each individual constraint in the basic constraint set. |
156 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryDeviceID) { | 178 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryDeviceID) { |
157 const std::string kDeviceID = "Some ID"; | 179 const std::string kDeviceID = "Some ID"; |
158 constraint_factory_.Reset(); | 180 constraint_factory_.Reset(); |
159 constraint_factory_.basic().deviceId.setExact( | 181 constraint_factory_.basic().deviceId.setExact( |
160 blink::WebString::fromASCII(kDeviceID)); | 182 blink::WebString::fromASCII(kDeviceID)); |
161 auto result = SelectSettings(); | 183 auto result = SelectSettings(); |
162 EXPECT_TRUE(result.HasValue()); | 184 EXPECT_TRUE(result.HasValue()); |
163 EXPECT_EQ(kDeviceID, result.device_id()); | 185 EXPECT_EQ(kDeviceID, result.device_id()); |
164 // Other settings should have default values. | 186 // Other settings should have default values. |
165 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 187 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
166 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 188 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
167 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 189 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
168 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 190 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
| 191 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
169 } | 192 } |
170 | 193 |
171 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealDeviceID) { | 194 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealDeviceID) { |
172 const std::string kDeviceID = "Some ID"; | 195 const std::string kDeviceID = "Some ID"; |
173 const std::string kIdealID = "Ideal ID"; | 196 const std::string kIdealID = "Ideal ID"; |
174 blink::WebVector<blink::WebString> device_ids(static_cast<size_t>(2)); | 197 blink::WebVector<blink::WebString> device_ids(static_cast<size_t>(2)); |
175 device_ids[0] = blink::WebString::fromASCII(kDeviceID); | 198 device_ids[0] = blink::WebString::fromASCII(kDeviceID); |
176 device_ids[1] = blink::WebString::fromASCII(kIdealID); | 199 device_ids[1] = blink::WebString::fromASCII(kIdealID); |
177 constraint_factory_.Reset(); | 200 constraint_factory_.Reset(); |
178 constraint_factory_.basic().deviceId.setExact(device_ids); | 201 constraint_factory_.basic().deviceId.setExact(device_ids); |
179 | 202 |
180 blink::WebVector<blink::WebString> ideal_id(static_cast<size_t>(1)); | 203 blink::WebVector<blink::WebString> ideal_id(static_cast<size_t>(1)); |
181 ideal_id[0] = blink::WebString::fromASCII(kIdealID); | 204 ideal_id[0] = blink::WebString::fromASCII(kIdealID); |
182 constraint_factory_.basic().deviceId.setIdeal(ideal_id); | 205 constraint_factory_.basic().deviceId.setIdeal(ideal_id); |
183 | 206 |
184 auto result = SelectSettings(); | 207 auto result = SelectSettings(); |
185 EXPECT_TRUE(result.HasValue()); | 208 EXPECT_TRUE(result.HasValue()); |
186 EXPECT_EQ(kIdealID, result.device_id()); | 209 EXPECT_EQ(kIdealID, result.device_id()); |
187 // Other settings should have default values. | 210 // Other settings should have default values. |
188 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 211 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
189 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 212 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
190 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 213 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
191 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 214 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
| 215 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
192 } | 216 } |
193 | 217 |
194 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryNoiseReduction) { | 218 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryNoiseReduction) { |
195 constraint_factory_.Reset(); | 219 constraint_factory_.Reset(); |
196 const bool kNoiseReductionValues[] = {true, false}; | 220 const bool kNoiseReductionValues[] = {true, false}; |
197 for (auto noise_reduction : kNoiseReductionValues) { | 221 for (auto noise_reduction : kNoiseReductionValues) { |
198 constraint_factory_.basic().googNoiseReduction.setExact(noise_reduction); | 222 constraint_factory_.basic().googNoiseReduction.setExact(noise_reduction); |
199 auto result = SelectSettings(); | 223 auto result = SelectSettings(); |
200 EXPECT_TRUE(result.HasValue()); | 224 EXPECT_TRUE(result.HasValue()); |
201 EXPECT_EQ(noise_reduction, result.noise_reduction()); | 225 EXPECT_EQ(noise_reduction, result.noise_reduction()); |
202 // Other settings should have default values. | 226 // Other settings should have default values. |
203 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 227 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
204 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 228 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
205 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 229 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
206 EXPECT_EQ(std::string(), result.device_id()); | 230 EXPECT_EQ(std::string(), result.device_id()); |
| 231 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
207 } | 232 } |
208 } | 233 } |
209 | 234 |
210 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealNoiseReduction) { | 235 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealNoiseReduction) { |
211 constraint_factory_.Reset(); | 236 constraint_factory_.Reset(); |
212 const bool kNoiseReductionValues[] = {true, false}; | 237 const bool kNoiseReductionValues[] = {true, false}; |
213 for (auto noise_reduction : kNoiseReductionValues) { | 238 for (auto noise_reduction : kNoiseReductionValues) { |
214 constraint_factory_.basic().googNoiseReduction.setIdeal(noise_reduction); | 239 constraint_factory_.basic().googNoiseReduction.setIdeal(noise_reduction); |
215 auto result = SelectSettings(); | 240 auto result = SelectSettings(); |
216 EXPECT_TRUE(result.HasValue()); | 241 EXPECT_TRUE(result.HasValue()); |
217 EXPECT_EQ(noise_reduction, result.noise_reduction()); | 242 EXPECT_EQ(noise_reduction, result.noise_reduction()); |
218 // Other settings should have default values. | 243 // Other settings should have default values. |
219 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 244 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
220 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 245 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
221 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 246 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
222 EXPECT_EQ(std::string(), result.device_id()); | 247 EXPECT_EQ(std::string(), result.device_id()); |
| 248 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
223 } | 249 } |
224 } | 250 } |
225 | 251 |
226 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactHeight) { | 252 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactHeight) { |
227 constraint_factory_.Reset(); | 253 constraint_factory_.Reset(); |
228 const int kHeight = 1000; | 254 const int kHeight = 1000; |
229 constraint_factory_.basic().height.setExact(kHeight); | 255 constraint_factory_.basic().height.setExact(kHeight); |
230 auto result = SelectSettings(); | 256 auto result = SelectSettings(); |
231 EXPECT_TRUE(result.HasValue()); | 257 EXPECT_TRUE(result.HasValue()); |
232 EXPECT_EQ(kHeight, result.Height()); | 258 EXPECT_EQ(kHeight, result.Height()); |
233 // The algorithm tries to preserve the default aspect ratio. | 259 // The algorithm tries to preserve the default aspect ratio. |
234 EXPECT_EQ(std::round(kHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 260 EXPECT_EQ(std::round(kHeight * kDefaultScreenCastAspectRatio), |
235 result.Width()); | 261 result.Width()); |
236 CheckNonResolutionDefaults(result); | 262 CheckNonResolutionDefaults(result); |
| 263 EXPECT_EQ(1.0 / kHeight, result.track_adapter_settings().min_aspect_ratio); |
| 264 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kHeight, |
| 265 result.track_adapter_settings().max_aspect_ratio); |
| 266 CheckTrackAdapterSettingsEqualsFormat(result); |
237 } | 267 } |
238 | 268 |
239 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinHeight) { | 269 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinHeight) { |
240 constraint_factory_.Reset(); | 270 constraint_factory_.Reset(); |
241 const int kHeight = 1000; | 271 const int kHeight = 1000; |
242 constraint_factory_.basic().height.setMin(kHeight); | 272 constraint_factory_.basic().height.setMin(kHeight); |
243 auto result = SelectSettings(); | 273 auto result = SelectSettings(); |
244 EXPECT_TRUE(result.HasValue()); | 274 EXPECT_TRUE(result.HasValue()); |
245 // kHeight is greater that the default, so expect kHeight. | 275 // kHeight is greater that the default, so expect kHeight. |
246 EXPECT_EQ(kHeight, result.Height()); | 276 EXPECT_EQ(kHeight, result.Height()); |
247 EXPECT_EQ(std::round(kHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 277 EXPECT_EQ(std::round(kHeight * kDefaultScreenCastAspectRatio), |
248 result.Width()); | 278 result.Width()); |
249 CheckNonResolutionDefaults(result); | 279 CheckNonResolutionDefaults(result); |
| 280 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 281 result.track_adapter_settings().min_aspect_ratio); |
| 282 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kHeight, |
| 283 result.track_adapter_settings().max_aspect_ratio); |
| 284 CheckTrackAdapterSettingsEqualsFormat(result); |
250 | 285 |
251 const int kSmallHeight = 100; | 286 const int kSmallHeight = 100; |
252 constraint_factory_.basic().height.setMin(kSmallHeight); | 287 constraint_factory_.basic().height.setMin(kSmallHeight); |
253 result = SelectSettings(); | 288 result = SelectSettings(); |
254 EXPECT_TRUE(result.HasValue()); | 289 EXPECT_TRUE(result.HasValue()); |
255 // kSmallHeight is less that the default, so expect the default. | 290 // kSmallHeight is less that the default, so expect the default. |
256 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 291 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
257 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 292 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
258 CheckNonResolutionDefaults(result); | 293 CheckNonResolutionDefaults(result); |
| 294 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 295 result.track_adapter_settings().min_aspect_ratio); |
| 296 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kSmallHeight, |
| 297 result.track_adapter_settings().max_aspect_ratio); |
| 298 CheckTrackAdapterSettingsEqualsFormat(result); |
259 } | 299 } |
260 | 300 |
261 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxHeight) { | 301 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxHeight) { |
262 constraint_factory_.Reset(); | 302 constraint_factory_.Reset(); |
263 const int kHeight = 1000; | 303 const int kHeight = 1000; |
264 constraint_factory_.basic().height.setMax(kHeight); | 304 constraint_factory_.basic().height.setMax(kHeight); |
265 auto result = SelectSettings(); | 305 auto result = SelectSettings(); |
266 EXPECT_TRUE(result.HasValue()); | 306 EXPECT_TRUE(result.HasValue()); |
267 // kHeight is greater that the default, so expect the default. | 307 // kHeight is greater that the default, so expect the default. |
268 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 308 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
269 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 309 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
270 CheckNonResolutionDefaults(result); | 310 CheckNonResolutionDefaults(result); |
| 311 EXPECT_EQ(1.0 / kHeight, result.track_adapter_settings().min_aspect_ratio); |
| 312 EXPECT_EQ(kMaxScreenCastDimension, |
| 313 result.track_adapter_settings().max_aspect_ratio); |
| 314 CheckTrackAdapterSettingsEqualsFormat(result); |
271 | 315 |
272 const int kSmallHeight = 100; | 316 const int kSmallHeight = 100; |
273 constraint_factory_.basic().height.setMax(kSmallHeight); | 317 constraint_factory_.basic().height.setMax(kSmallHeight); |
274 result = SelectSettings(); | 318 result = SelectSettings(); |
275 EXPECT_TRUE(result.HasValue()); | 319 EXPECT_TRUE(result.HasValue()); |
276 // kSmallHeight is less that the default, so expect kSmallHeight. | 320 // kSmallHeight is less that the default, so expect kSmallHeight. |
277 EXPECT_EQ(kSmallHeight, result.Height()); | 321 EXPECT_EQ(kSmallHeight, result.Height()); |
278 EXPECT_EQ( | 322 EXPECT_EQ(std::round(kSmallHeight * kDefaultScreenCastAspectRatio), |
279 std::round(kSmallHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 323 result.Width()); |
280 result.Width()); | |
281 CheckNonResolutionDefaults(result); | 324 CheckNonResolutionDefaults(result); |
| 325 EXPECT_EQ(1.0 / kSmallHeight, |
| 326 result.track_adapter_settings().min_aspect_ratio); |
| 327 EXPECT_EQ(kMaxScreenCastDimension, |
| 328 result.track_adapter_settings().max_aspect_ratio); |
| 329 CheckTrackAdapterSettingsEqualsFormat(result); |
282 } | 330 } |
283 | 331 |
284 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryHeightRange) { | 332 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryHeightRange) { |
285 constraint_factory_.Reset(); | 333 constraint_factory_.Reset(); |
286 { | 334 { |
287 const int kMinHeight = 300; | 335 const int kMinHeight = 300; |
288 const int kMaxHeight = 1000; | 336 const int kMaxHeight = 1000; |
289 constraint_factory_.basic().height.setMin(kMinHeight); | 337 constraint_factory_.basic().height.setMin(kMinHeight); |
290 constraint_factory_.basic().height.setMax(kMaxHeight); | 338 constraint_factory_.basic().height.setMax(kMaxHeight); |
291 auto result = SelectSettings(); | 339 auto result = SelectSettings(); |
292 EXPECT_TRUE(result.HasValue()); | 340 EXPECT_TRUE(result.HasValue()); |
293 // The range includes the default, so expect the default. | 341 // The range includes the default, so expect the default. |
294 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 342 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
295 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 343 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
296 CheckNonResolutionDefaults(result); | 344 CheckNonResolutionDefaults(result); |
| 345 EXPECT_EQ(1.0 / kMaxHeight, |
| 346 result.track_adapter_settings().min_aspect_ratio); |
| 347 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight, |
| 348 result.track_adapter_settings().max_aspect_ratio); |
| 349 CheckTrackAdapterSettingsEqualsFormat(result); |
297 } | 350 } |
298 | 351 |
299 { | 352 { |
300 const int kMinHeight = 900; | 353 const int kMinHeight = 900; |
301 const int kMaxHeight = 1000; | 354 const int kMaxHeight = 1000; |
302 constraint_factory_.basic().height.setMin(kMinHeight); | 355 constraint_factory_.basic().height.setMin(kMinHeight); |
303 constraint_factory_.basic().height.setMax(kMaxHeight); | 356 constraint_factory_.basic().height.setMax(kMaxHeight); |
304 auto result = SelectSettings(); | 357 auto result = SelectSettings(); |
305 EXPECT_TRUE(result.HasValue()); | 358 EXPECT_TRUE(result.HasValue()); |
306 // The whole range is greater than the default, so expect the range minimum. | 359 // The whole range is greater than the default, so expect the range minimum. |
307 EXPECT_EQ(kMinHeight, result.Height()); | 360 EXPECT_EQ(kMinHeight, result.Height()); |
308 EXPECT_EQ( | 361 EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio), |
309 std::round(kMinHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 362 result.Width()); |
310 result.Width()); | |
311 CheckNonResolutionDefaults(result); | 363 CheckNonResolutionDefaults(result); |
| 364 EXPECT_EQ(1.0 / kMaxHeight, |
| 365 result.track_adapter_settings().min_aspect_ratio); |
| 366 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight, |
| 367 result.track_adapter_settings().max_aspect_ratio); |
| 368 CheckTrackAdapterSettingsEqualsFormat(result); |
312 } | 369 } |
313 | 370 |
314 { | 371 { |
315 const int kMinHeight = 300; | 372 const int kMinHeight = 300; |
316 const int kMaxHeight = 400; | 373 const int kMaxHeight = 400; |
317 constraint_factory_.basic().height.setMin(kMinHeight); | 374 constraint_factory_.basic().height.setMin(kMinHeight); |
318 constraint_factory_.basic().height.setMax(kMaxHeight); | 375 constraint_factory_.basic().height.setMax(kMaxHeight); |
319 auto result = SelectSettings(); | 376 auto result = SelectSettings(); |
320 EXPECT_TRUE(result.HasValue()); | 377 EXPECT_TRUE(result.HasValue()); |
321 // The whole range is less than the default, so expect the range maximum. | 378 // The whole range is less than the default, so expect the range maximum. |
322 EXPECT_EQ(kMaxHeight, result.Height()); | 379 EXPECT_EQ(kMaxHeight, result.Height()); |
323 EXPECT_EQ( | 380 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio), |
324 std::round(kMaxHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 381 result.Width()); |
325 result.Width()); | |
326 CheckNonResolutionDefaults(result); | 382 CheckNonResolutionDefaults(result); |
| 383 EXPECT_EQ(1.0 / kMaxHeight, |
| 384 result.track_adapter_settings().min_aspect_ratio); |
| 385 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight, |
| 386 result.track_adapter_settings().max_aspect_ratio); |
| 387 CheckTrackAdapterSettingsEqualsFormat(result); |
327 } | 388 } |
328 } | 389 } |
329 | 390 |
330 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealHeight) { | 391 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealHeight) { |
331 // Unconstrained. | 392 // Unconstrained. |
332 { | 393 { |
333 constraint_factory_.Reset(); | 394 constraint_factory_.Reset(); |
334 const int kIdealHeight = 1000; | 395 const int kIdealHeight = 1000; |
335 constraint_factory_.basic().height.setIdeal(kIdealHeight); | 396 constraint_factory_.basic().height.setIdeal(kIdealHeight); |
336 auto result = SelectSettings(); | 397 auto result = SelectSettings(); |
337 EXPECT_TRUE(result.HasValue()); | 398 EXPECT_TRUE(result.HasValue()); |
338 EXPECT_EQ(kIdealHeight, result.Height()); | 399 EXPECT_EQ(kIdealHeight, result.Height()); |
339 // When ideal height is given, the algorithm returns a width that is closest | 400 // When ideal height is given, the algorithm returns a width that is closest |
340 // to height * kDefaultAspectRatio. | 401 // to height * kDefaultAspectRatio. |
341 EXPECT_EQ( | 402 EXPECT_EQ(std::round(kIdealHeight * kDefaultScreenCastAspectRatio), |
342 std::round(kIdealHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 403 result.Width()); |
343 result.Width()); | |
344 CheckNonResolutionDefaults(result); | 404 CheckNonResolutionDefaults(result); |
| 405 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
345 } | 406 } |
346 | 407 |
347 // Ideal greater than maximum. | 408 // Ideal greater than maximum. |
348 { | 409 { |
349 constraint_factory_.Reset(); | 410 constraint_factory_.Reset(); |
350 const int kIdealHeight = 1000; | 411 const int kIdealHeight = 1000; |
351 const int kMaxHeight = 800; | 412 const int kMaxHeight = 800; |
352 constraint_factory_.basic().height.setIdeal(kIdealHeight); | 413 constraint_factory_.basic().height.setIdeal(kIdealHeight); |
353 constraint_factory_.basic().height.setMax(kMaxHeight); | 414 constraint_factory_.basic().height.setMax(kMaxHeight); |
354 auto result = SelectSettings(); | 415 auto result = SelectSettings(); |
355 EXPECT_TRUE(result.HasValue()); | 416 EXPECT_TRUE(result.HasValue()); |
356 // Ideal height is greater than the maximum, expect maximum. | 417 // Ideal height is greater than the maximum, expect maximum. |
357 EXPECT_EQ(kMaxHeight, result.Height()); | 418 EXPECT_EQ(kMaxHeight, result.Height()); |
358 // Expect closest to kMaxHeight * kDefaultAspectRatio. | 419 // Expect closest to kMaxHeight * kDefaultAspectRatio. |
359 EXPECT_EQ( | 420 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio), |
360 std::round(kMaxHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 421 result.Width()); |
361 result.Width()); | |
362 CheckNonResolutionDefaults(result); | 422 CheckNonResolutionDefaults(result); |
| 423 EXPECT_EQ(1.0 / kMaxHeight, |
| 424 result.track_adapter_settings().min_aspect_ratio); |
| 425 EXPECT_EQ(kMaxScreenCastDimension, |
| 426 result.track_adapter_settings().max_aspect_ratio); |
| 427 CheckTrackAdapterSettingsEqualsFormat(result); |
363 } | 428 } |
364 | 429 |
365 // Ideal less than minimum. | 430 // Ideal less than minimum. |
366 { | 431 { |
367 constraint_factory_.Reset(); | 432 constraint_factory_.Reset(); |
368 const int kIdealHeight = 1000; | 433 const int kIdealHeight = 1000; |
369 const int kMinHeight = 1200; | 434 const int kMinHeight = 1200; |
370 constraint_factory_.basic().height.setIdeal(kIdealHeight); | 435 constraint_factory_.basic().height.setIdeal(kIdealHeight); |
371 constraint_factory_.basic().height.setMin(kMinHeight); | 436 constraint_factory_.basic().height.setMin(kMinHeight); |
372 auto result = SelectSettings(); | 437 auto result = SelectSettings(); |
373 EXPECT_TRUE(result.HasValue()); | 438 EXPECT_TRUE(result.HasValue()); |
374 // Ideal height is less than the minimum, expect minimum. | 439 // Ideal height is less than the minimum, expect minimum. |
375 EXPECT_EQ(kMinHeight, result.Height()); | 440 EXPECT_EQ(kMinHeight, result.Height()); |
376 // Expect closest to kMinHeight * kDefaultAspectRatio. | 441 // Expect closest to kMinHeight * kDefaultAspectRatio. |
377 EXPECT_EQ( | 442 EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio), |
378 std::round(kMinHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 443 result.Width()); |
379 result.Width()); | |
380 CheckNonResolutionDefaults(result); | 444 CheckNonResolutionDefaults(result); |
| 445 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 446 result.track_adapter_settings().min_aspect_ratio); |
| 447 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight, |
| 448 result.track_adapter_settings().max_aspect_ratio); |
| 449 CheckTrackAdapterSettingsEqualsFormat(result); |
381 } | 450 } |
382 | 451 |
383 // Ideal intersects a box. | 452 // Ideal intersects a box. |
384 { | 453 { |
385 constraint_factory_.Reset(); | 454 constraint_factory_.Reset(); |
386 constraint_factory_.basic().height.setMin(500); | 455 constraint_factory_.basic().height.setMin(500); |
387 constraint_factory_.basic().height.setMax(1000); | 456 constraint_factory_.basic().height.setMax(1000); |
388 constraint_factory_.basic().width.setMin(100); | 457 constraint_factory_.basic().width.setMin(100); |
389 constraint_factory_.basic().width.setMax(500); | 458 constraint_factory_.basic().width.setMax(500); |
390 const int kIdealHeight = 750; | 459 const int kIdealHeight = 750; |
391 constraint_factory_.basic().height.setIdeal(kIdealHeight); | 460 constraint_factory_.basic().height.setIdeal(kIdealHeight); |
392 auto result = SelectSettings(); | 461 auto result = SelectSettings(); |
393 EXPECT_TRUE(result.HasValue()); | 462 EXPECT_TRUE(result.HasValue()); |
394 // Ideal height is included in the bounding box. | 463 // Ideal height is included in the bounding box. |
395 EXPECT_EQ(kIdealHeight, result.Height()); | 464 EXPECT_EQ(kIdealHeight, result.Height()); |
396 // Expect width closest to kIdealHeight * kDefaultAspectRatio, which is | 465 // Expect width closest to kIdealHeight * kDefaultAspectRatio, which is |
397 // outside the box. Closest is max width. | 466 // outside the box. Closest is max width. |
398 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 467 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
399 CheckNonResolutionDefaults(result); | 468 CheckNonResolutionDefaults(result); |
| 469 EXPECT_EQ(100.0 / 1000.0, result.track_adapter_settings().min_aspect_ratio); |
| 470 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 471 CheckTrackAdapterSettingsEqualsFormat(result); |
400 | 472 |
401 constraint_factory_.basic().width.setMin(1200); | 473 constraint_factory_.basic().width.setMin(1200); |
402 constraint_factory_.basic().width.setMax(2000); | 474 constraint_factory_.basic().width.setMax(2000); |
403 result = SelectSettings(); | 475 result = SelectSettings(); |
404 EXPECT_TRUE(result.HasValue()); | 476 EXPECT_TRUE(result.HasValue()); |
405 EXPECT_EQ(kIdealHeight, result.Height()); | 477 EXPECT_EQ(kIdealHeight, result.Height()); |
406 // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is | 478 // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is |
407 // min width. | 479 // min width. |
408 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); | 480 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); |
409 CheckNonResolutionDefaults(result); | 481 CheckNonResolutionDefaults(result); |
| 482 EXPECT_EQ(1200.0 / 1000.0, |
| 483 result.track_adapter_settings().min_aspect_ratio); |
| 484 EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 485 CheckTrackAdapterSettingsEqualsFormat(result); |
410 | 486 |
411 constraint_factory_.basic().width.setMin(100); | 487 constraint_factory_.basic().width.setMin(100); |
412 constraint_factory_.basic().width.setMax(500); | 488 constraint_factory_.basic().width.setMax(500); |
413 result = SelectSettings(); | 489 result = SelectSettings(); |
414 EXPECT_TRUE(result.HasValue()); | 490 EXPECT_TRUE(result.HasValue()); |
415 EXPECT_EQ(kIdealHeight, result.Height()); | 491 EXPECT_EQ(kIdealHeight, result.Height()); |
416 // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is | 492 // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is |
417 // max width. | 493 // max width. |
418 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 494 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
419 CheckNonResolutionDefaults(result); | 495 CheckNonResolutionDefaults(result); |
| 496 EXPECT_EQ(100.0 / 1000.0, result.track_adapter_settings().min_aspect_ratio); |
| 497 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 498 CheckTrackAdapterSettingsEqualsFormat(result); |
420 } | 499 } |
421 | 500 |
422 // Ideal outside the box, closest to the side coinciding with max height. | 501 // Ideal outside the box, closest to the side coinciding with max height. |
423 { | 502 { |
424 const int kMaxHeight = 1000; | 503 const int kMaxHeight = 1000; |
425 constraint_factory_.Reset(); | 504 constraint_factory_.Reset(); |
426 constraint_factory_.basic().height.setMin(500); | 505 constraint_factory_.basic().height.setMin(500); |
427 constraint_factory_.basic().height.setMax(kMaxHeight); | 506 constraint_factory_.basic().height.setMax(kMaxHeight); |
428 constraint_factory_.basic().width.setMin(100); | 507 constraint_factory_.basic().width.setMin(100); |
429 constraint_factory_.basic().width.setMax(500); | 508 constraint_factory_.basic().width.setMax(500); |
430 constraint_factory_.basic().height.setIdeal(1200); | 509 constraint_factory_.basic().height.setIdeal(1200); |
431 auto result = SelectSettings(); | 510 auto result = SelectSettings(); |
432 EXPECT_TRUE(result.HasValue()); | 511 EXPECT_TRUE(result.HasValue()); |
433 EXPECT_EQ(kMaxHeight, result.Height()); | 512 EXPECT_EQ(kMaxHeight, result.Height()); |
434 // Expect width closest to kMaxHeight * kDefaultAspectRatio, which is | 513 // Expect width closest to kMaxHeight * kDefaultAspectRatio, which is |
435 // outside the box. Closest it max width. | 514 // outside the box. Closest it max width. |
436 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 515 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
437 CheckNonResolutionDefaults(result); | 516 CheckNonResolutionDefaults(result); |
| 517 EXPECT_EQ(100.0 / kMaxHeight, |
| 518 result.track_adapter_settings().min_aspect_ratio); |
| 519 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 520 CheckTrackAdapterSettingsEqualsFormat(result); |
438 | 521 |
439 constraint_factory_.basic().width.setMin(1500); | 522 constraint_factory_.basic().width.setMin(1500); |
440 constraint_factory_.basic().width.setMax(2000); | 523 constraint_factory_.basic().width.setMax(2000); |
441 result = SelectSettings(); | 524 result = SelectSettings(); |
442 EXPECT_TRUE(result.HasValue()); | 525 EXPECT_TRUE(result.HasValue()); |
443 EXPECT_EQ(kMaxHeight, result.Height()); | 526 EXPECT_EQ(kMaxHeight, result.Height()); |
444 // kMaxHeight * kDefaultAspectRatio is outside the box. Closest is min | 527 // kMaxHeight * kDefaultAspectRatio is outside the box. Closest is min |
445 // width. | 528 // width. |
446 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); | 529 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); |
447 CheckNonResolutionDefaults(result); | 530 CheckNonResolutionDefaults(result); |
| 531 EXPECT_EQ(1500.0 / kMaxHeight, |
| 532 result.track_adapter_settings().min_aspect_ratio); |
| 533 EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 534 CheckTrackAdapterSettingsEqualsFormat(result); |
448 | 535 |
449 constraint_factory_.basic().width.setMin(100); | 536 constraint_factory_.basic().width.setMin(100); |
450 result = SelectSettings(); | 537 result = SelectSettings(); |
451 EXPECT_TRUE(result.HasValue()); | 538 EXPECT_TRUE(result.HasValue()); |
452 EXPECT_EQ(kMaxHeight, result.Height()); | 539 EXPECT_EQ(kMaxHeight, result.Height()); |
453 // kMaxHeight * kDefaultAspectRatio is within the width limits. | 540 // kMaxHeight * kDefaultAspectRatio is within the width limits. |
454 EXPECT_EQ( | 541 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio), |
455 std::round(kMaxHeight * MediaStreamVideoSource::kDefaultAspectRatio), | 542 result.Width()); |
456 result.Width()); | |
457 CheckNonResolutionDefaults(result); | 543 CheckNonResolutionDefaults(result); |
| 544 EXPECT_EQ(100.0 / kMaxHeight, |
| 545 result.track_adapter_settings().min_aspect_ratio); |
| 546 EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 547 CheckTrackAdapterSettingsEqualsFormat(result); |
458 } | 548 } |
459 | 549 |
460 // Ideal outside the constrained set, closest to a single point. | 550 // Ideal outside the constrained set, closest to a single point. |
461 { | 551 { |
462 constraint_factory_.Reset(); | 552 constraint_factory_.Reset(); |
463 constraint_factory_.basic().height.setMin(500); | 553 constraint_factory_.basic().height.setMin(500); |
464 constraint_factory_.basic().height.setMax(1000); | 554 constraint_factory_.basic().height.setMax(1000); |
465 constraint_factory_.basic().width.setMin(500); | 555 constraint_factory_.basic().width.setMin(500); |
466 constraint_factory_.basic().width.setMax(1000); | 556 constraint_factory_.basic().width.setMax(1000); |
467 constraint_factory_.basic().aspectRatio.setMin(1.0); | 557 constraint_factory_.basic().aspectRatio.setMin(1.0); |
468 constraint_factory_.basic().height.setIdeal(1200); | 558 constraint_factory_.basic().height.setIdeal(1200); |
469 auto result = SelectSettings(); | 559 auto result = SelectSettings(); |
470 EXPECT_TRUE(result.HasValue()); | 560 EXPECT_TRUE(result.HasValue()); |
471 // (max-height, max-width) is the single point closest to the ideal line. | 561 // (max-height, max-width) is the single point closest to the ideal line. |
472 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 562 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
473 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 563 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
474 CheckNonResolutionDefaults(result); | 564 CheckNonResolutionDefaults(result); |
| 565 EXPECT_EQ(1.0, result.track_adapter_settings().min_aspect_ratio); |
| 566 EXPECT_EQ(1000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 567 CheckTrackAdapterSettingsEqualsFormat(result); |
475 } | 568 } |
476 } | 569 } |
477 | 570 |
478 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactWidth) { | 571 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactWidth) { |
479 constraint_factory_.Reset(); | 572 constraint_factory_.Reset(); |
480 const int kWidth = 1000; | 573 const int kWidth = 1000; |
481 constraint_factory_.basic().width.setExact(kWidth); | 574 constraint_factory_.basic().width.setExact(kWidth); |
482 auto result = SelectSettings(); | 575 auto result = SelectSettings(); |
483 EXPECT_TRUE(result.HasValue()); | 576 EXPECT_TRUE(result.HasValue()); |
484 EXPECT_EQ(kWidth, result.Width()); | 577 EXPECT_EQ(kWidth, result.Width()); |
485 EXPECT_EQ(std::round(kWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 578 EXPECT_EQ(std::round(kWidth / kDefaultScreenCastAspectRatio), |
486 result.Height()); | 579 result.Height()); |
487 CheckNonResolutionDefaults(result); | 580 CheckNonResolutionDefaults(result); |
| 581 EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension, |
| 582 result.track_adapter_settings().min_aspect_ratio); |
| 583 EXPECT_EQ(static_cast<double>(kWidth) / kMinScreenCastDimension, |
| 584 result.track_adapter_settings().max_aspect_ratio); |
| 585 CheckTrackAdapterSettingsEqualsFormat(result); |
488 } | 586 } |
489 | 587 |
490 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinWidth) { | 588 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinWidth) { |
491 constraint_factory_.Reset(); | 589 constraint_factory_.Reset(); |
492 const int kWidth = 1000; | 590 const int kWidth = 1000; |
493 constraint_factory_.basic().width.setMin(kWidth); | 591 constraint_factory_.basic().width.setMin(kWidth); |
494 auto result = SelectSettings(); | 592 auto result = SelectSettings(); |
495 EXPECT_TRUE(result.HasValue()); | 593 EXPECT_TRUE(result.HasValue()); |
496 // kWidth is greater that the default, so expect kWidth. | 594 // kWidth is greater that the default, so expect kWidth. |
497 EXPECT_EQ(kWidth, result.Width()); | 595 EXPECT_EQ(kWidth, result.Width()); |
498 EXPECT_EQ(std::round(kWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 596 EXPECT_EQ(std::round(kWidth / kDefaultScreenCastAspectRatio), |
499 result.Height()); | 597 result.Height()); |
500 CheckNonResolutionDefaults(result); | 598 CheckNonResolutionDefaults(result); |
| 599 EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension, |
| 600 result.track_adapter_settings().min_aspect_ratio); |
| 601 EXPECT_EQ( |
| 602 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
| 603 result.track_adapter_settings().max_aspect_ratio); |
| 604 CheckTrackAdapterSettingsEqualsFormat(result); |
501 | 605 |
502 const int kSmallWidth = 100; | 606 const int kSmallWidth = 100; |
503 constraint_factory_.basic().width.setMin(kSmallWidth); | 607 constraint_factory_.basic().width.setMin(kSmallWidth); |
504 result = SelectSettings(); | 608 result = SelectSettings(); |
505 EXPECT_TRUE(result.HasValue()); | 609 EXPECT_TRUE(result.HasValue()); |
506 // kSmallWidth is less that the default, so expect the default. | 610 // kSmallWidth is less that the default, so expect the default. |
507 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 611 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
508 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 612 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
509 CheckNonResolutionDefaults(result); | 613 CheckNonResolutionDefaults(result); |
| 614 EXPECT_EQ(static_cast<double>(kSmallWidth) / kMaxScreenCastDimension, |
| 615 result.track_adapter_settings().min_aspect_ratio); |
| 616 EXPECT_EQ( |
| 617 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
| 618 result.track_adapter_settings().max_aspect_ratio); |
| 619 CheckTrackAdapterSettingsEqualsFormat(result); |
510 } | 620 } |
511 | 621 |
512 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxWidth) { | 622 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxWidth) { |
513 constraint_factory_.Reset(); | 623 constraint_factory_.Reset(); |
514 const int kWidth = 1000; | 624 const int kWidth = 1000; |
515 constraint_factory_.basic().width.setMax(kWidth); | 625 constraint_factory_.basic().width.setMax(kWidth); |
516 auto result = SelectSettings(); | 626 auto result = SelectSettings(); |
517 EXPECT_TRUE(result.HasValue()); | 627 EXPECT_TRUE(result.HasValue()); |
518 // kWidth is greater that the default, so expect the default. | 628 // kWidth is greater that the default, so expect the default. |
519 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 629 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
520 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 630 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
521 CheckNonResolutionDefaults(result); | 631 CheckNonResolutionDefaults(result); |
| 632 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 633 result.track_adapter_settings().min_aspect_ratio); |
| 634 EXPECT_EQ(static_cast<double>(kWidth) / kMinScreenCastDimension, |
| 635 result.track_adapter_settings().max_aspect_ratio); |
| 636 CheckTrackAdapterSettingsEqualsFormat(result); |
522 | 637 |
523 const int kSmallWidth = 100; | 638 const int kSmallWidth = 100; |
524 constraint_factory_.basic().width.setMax(kSmallWidth); | 639 constraint_factory_.basic().width.setMax(kSmallWidth); |
525 result = SelectSettings(); | 640 result = SelectSettings(); |
526 EXPECT_TRUE(result.HasValue()); | 641 EXPECT_TRUE(result.HasValue()); |
527 // kSmallWidth is less that the default, so expect kSmallWidth. | 642 // kSmallWidth is less that the default, so expect kSmallWidth. |
528 EXPECT_EQ(kSmallWidth, result.Width()); | 643 EXPECT_EQ(kSmallWidth, result.Width()); |
529 EXPECT_EQ( | 644 EXPECT_EQ(std::round(kSmallWidth / kDefaultScreenCastAspectRatio), |
530 std::round(kSmallWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 645 result.Height()); |
531 result.Height()); | |
532 CheckNonResolutionDefaults(result); | 646 CheckNonResolutionDefaults(result); |
| 647 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 648 result.track_adapter_settings().min_aspect_ratio); |
| 649 EXPECT_EQ(static_cast<double>(kSmallWidth) / kMinScreenCastDimension, |
| 650 result.track_adapter_settings().max_aspect_ratio); |
| 651 CheckTrackAdapterSettingsEqualsFormat(result); |
533 } | 652 } |
534 | 653 |
535 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryWidthRange) { | 654 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryWidthRange) { |
536 constraint_factory_.Reset(); | 655 constraint_factory_.Reset(); |
537 { | 656 { |
538 const int kMinWidth = 300; | 657 const int kMinWidth = 300; |
539 const int kMaxWidth = 1000; | 658 const int kMaxWidth = 1000; |
540 constraint_factory_.basic().width.setMin(kMinWidth); | 659 constraint_factory_.basic().width.setMin(kMinWidth); |
541 constraint_factory_.basic().width.setMax(kMaxWidth); | 660 constraint_factory_.basic().width.setMax(kMaxWidth); |
542 auto result = SelectSettings(); | 661 auto result = SelectSettings(); |
543 EXPECT_TRUE(result.HasValue()); | 662 EXPECT_TRUE(result.HasValue()); |
544 // The range includes the default, so expect the default. | 663 // The range includes the default, so expect the default. |
545 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 664 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
546 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 665 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
547 CheckNonResolutionDefaults(result); | 666 CheckNonResolutionDefaults(result); |
| 667 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension, |
| 668 result.track_adapter_settings().min_aspect_ratio); |
| 669 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension, |
| 670 result.track_adapter_settings().max_aspect_ratio); |
| 671 CheckTrackAdapterSettingsEqualsFormat(result); |
548 } | 672 } |
549 | 673 |
550 { | 674 { |
551 const int kMinWidth = 900; | 675 const int kMinWidth = 900; |
552 const int kMaxWidth = 1000; | 676 const int kMaxWidth = 1000; |
553 constraint_factory_.basic().width.setMin(kMinWidth); | 677 constraint_factory_.basic().width.setMin(kMinWidth); |
554 constraint_factory_.basic().width.setMax(kMaxWidth); | 678 constraint_factory_.basic().width.setMax(kMaxWidth); |
555 auto result = SelectSettings(); | 679 auto result = SelectSettings(); |
556 EXPECT_TRUE(result.HasValue()); | 680 EXPECT_TRUE(result.HasValue()); |
557 // The whole range is greater than the default, so expect the range minimum. | 681 // The whole range is greater than the default, so expect the range minimum. |
558 EXPECT_EQ(kMinWidth, result.Width()); | 682 EXPECT_EQ(kMinWidth, result.Width()); |
559 EXPECT_EQ( | 683 EXPECT_EQ(std::round(kMinWidth / kDefaultScreenCastAspectRatio), |
560 std::round(kMinWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 684 result.Height()); |
561 result.Height()); | |
562 CheckNonResolutionDefaults(result); | 685 CheckNonResolutionDefaults(result); |
| 686 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension, |
| 687 result.track_adapter_settings().min_aspect_ratio); |
| 688 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension, |
| 689 result.track_adapter_settings().max_aspect_ratio); |
| 690 CheckTrackAdapterSettingsEqualsFormat(result); |
563 } | 691 } |
564 | 692 |
565 { | 693 { |
566 const int kMinWidth = 300; | 694 const int kMinWidth = 300; |
567 const int kMaxWidth = 400; | 695 const int kMaxWidth = 400; |
568 constraint_factory_.basic().width.setMin(kMinWidth); | 696 constraint_factory_.basic().width.setMin(kMinWidth); |
569 constraint_factory_.basic().width.setMax(kMaxWidth); | 697 constraint_factory_.basic().width.setMax(kMaxWidth); |
570 auto result = SelectSettings(); | 698 auto result = SelectSettings(); |
571 EXPECT_TRUE(result.HasValue()); | 699 EXPECT_TRUE(result.HasValue()); |
572 // The whole range is less than the default, so expect the range maximum. | 700 // The whole range is less than the default, so expect the range maximum. |
573 EXPECT_EQ(kMaxWidth, result.Width()); | 701 EXPECT_EQ(kMaxWidth, result.Width()); |
574 EXPECT_EQ( | 702 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio), |
575 std::round(kMaxWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 703 result.Height()); |
576 result.Height()); | |
577 CheckNonResolutionDefaults(result); | 704 CheckNonResolutionDefaults(result); |
| 705 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension, |
| 706 result.track_adapter_settings().min_aspect_ratio); |
| 707 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension, |
| 708 result.track_adapter_settings().max_aspect_ratio); |
| 709 CheckTrackAdapterSettingsEqualsFormat(result); |
578 } | 710 } |
579 } | 711 } |
580 | 712 |
581 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealWidth) { | 713 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealWidth) { |
582 // Unconstrained | 714 // Unconstrained |
583 { | 715 { |
584 constraint_factory_.Reset(); | 716 constraint_factory_.Reset(); |
585 const int kIdealWidth = 1000; | 717 const int kIdealWidth = 1000; |
586 constraint_factory_.basic().width.setIdeal(kIdealWidth); | 718 constraint_factory_.basic().width.setIdeal(kIdealWidth); |
587 auto result = SelectSettings(); | 719 auto result = SelectSettings(); |
588 EXPECT_TRUE(result.HasValue()); | 720 EXPECT_TRUE(result.HasValue()); |
589 EXPECT_EQ(kIdealWidth, result.Width()); | 721 EXPECT_EQ(kIdealWidth, result.Width()); |
590 // When ideal width is given, the algorithm returns a height that is closest | 722 // When ideal width is given, the algorithm returns a height that is closest |
591 // to width / kDefaultAspectRatio. | 723 // to width / kDefaultAspectRatio. |
592 EXPECT_EQ( | 724 EXPECT_EQ(std::round(kIdealWidth / kDefaultScreenCastAspectRatio), |
593 std::round(kIdealWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 725 result.Height()); |
594 result.Height()); | |
595 CheckNonResolutionDefaults(result); | 726 CheckNonResolutionDefaults(result); |
| 727 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
596 } | 728 } |
597 | 729 |
598 // Ideal greater than maximum. | 730 // Ideal greater than maximum. |
599 { | 731 { |
600 constraint_factory_.Reset(); | 732 constraint_factory_.Reset(); |
601 const int kIdealWidth = 1000; | 733 const int kIdealWidth = 1000; |
602 const int kMaxWidth = 800; | 734 const int kMaxWidth = 800; |
603 constraint_factory_.basic().width.setIdeal(kIdealWidth); | 735 constraint_factory_.basic().width.setIdeal(kIdealWidth); |
604 constraint_factory_.basic().width.setMax(kMaxWidth); | 736 constraint_factory_.basic().width.setMax(kMaxWidth); |
605 auto result = SelectSettings(); | 737 auto result = SelectSettings(); |
606 EXPECT_TRUE(result.HasValue()); | 738 EXPECT_TRUE(result.HasValue()); |
607 EXPECT_EQ(kMaxWidth, result.Width()); | 739 EXPECT_EQ(kMaxWidth, result.Width()); |
608 // Expect closest to kMaxWidth / kDefaultAspectRatio. | 740 // Expect closest to kMaxWidth / kDefaultAspectRatio. |
609 EXPECT_EQ( | 741 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio), |
610 std::round(kMaxWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 742 result.Height()); |
611 result.Height()); | |
612 CheckNonResolutionDefaults(result); | 743 CheckNonResolutionDefaults(result); |
| 744 EXPECT_EQ(1.0 / kMaxScreenCastDimension, |
| 745 result.track_adapter_settings().min_aspect_ratio); |
| 746 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension, |
| 747 result.track_adapter_settings().max_aspect_ratio); |
| 748 CheckTrackAdapterSettingsEqualsFormat(result); |
613 } | 749 } |
614 | 750 |
615 // Ideal less than minimum. | 751 // Ideal less than minimum. |
616 { | 752 { |
617 constraint_factory_.Reset(); | 753 constraint_factory_.Reset(); |
618 const int kIdealWidth = 1000; | 754 const int kIdealWidth = 1000; |
619 const int kMinWidth = 1200; | 755 const int kMinWidth = 1200; |
620 constraint_factory_.basic().width.setIdeal(kIdealWidth); | 756 constraint_factory_.basic().width.setIdeal(kIdealWidth); |
621 constraint_factory_.basic().width.setMin(kMinWidth); | 757 constraint_factory_.basic().width.setMin(kMinWidth); |
622 auto result = SelectSettings(); | 758 auto result = SelectSettings(); |
623 EXPECT_TRUE(result.HasValue()); | 759 EXPECT_TRUE(result.HasValue()); |
624 EXPECT_EQ(kMinWidth, result.Width()); | 760 EXPECT_EQ(kMinWidth, result.Width()); |
625 // Expect closest to kMinWidth / kDefaultAspectRatio. | 761 // Expect closest to kMinWidth / kDefaultAspectRatio. |
| 762 EXPECT_EQ(std::round(kMinWidth / kDefaultScreenCastAspectRatio), |
| 763 result.Height()); |
| 764 CheckNonResolutionDefaults(result); |
| 765 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension, |
| 766 result.track_adapter_settings().min_aspect_ratio); |
626 EXPECT_EQ( | 767 EXPECT_EQ( |
627 std::round(kMinWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 768 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
628 result.Height()); | 769 result.track_adapter_settings().max_aspect_ratio); |
629 CheckNonResolutionDefaults(result); | 770 CheckTrackAdapterSettingsEqualsFormat(result); |
630 } | 771 } |
631 | 772 |
632 // Ideal intersects a box. | 773 // Ideal intersects a box. |
633 { | 774 { |
634 constraint_factory_.Reset(); | 775 constraint_factory_.Reset(); |
635 constraint_factory_.basic().width.setMin(500); | 776 constraint_factory_.basic().width.setMin(500); |
636 constraint_factory_.basic().width.setMax(1000); | 777 constraint_factory_.basic().width.setMax(1000); |
637 constraint_factory_.basic().height.setMin(100); | 778 constraint_factory_.basic().height.setMin(100); |
638 constraint_factory_.basic().height.setMax(500); | 779 constraint_factory_.basic().height.setMax(500); |
639 const int kIdealWidth = 750; | 780 const int kIdealWidth = 750; |
640 constraint_factory_.basic().width.setIdeal(kIdealWidth); | 781 constraint_factory_.basic().width.setIdeal(kIdealWidth); |
641 auto result = SelectSettings(); | 782 auto result = SelectSettings(); |
642 EXPECT_TRUE(result.HasValue()); | 783 EXPECT_TRUE(result.HasValue()); |
643 // Ideal width is included in the bounding box. | 784 // Ideal width is included in the bounding box. |
644 EXPECT_EQ(kIdealWidth, result.Width()); | 785 EXPECT_EQ(kIdealWidth, result.Width()); |
645 // Expect height closest to kIdealWidth / kDefaultAspectRatio, which is | 786 // Expect height closest to kIdealWidth / kDefaultAspectRatio, which is |
646 // outside the box. Closest is max height. | 787 // outside the box. Closest is max height. |
647 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 788 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
648 CheckNonResolutionDefaults(result); | 789 CheckNonResolutionDefaults(result); |
| 790 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 791 EXPECT_EQ(1000.0 / 100.0, result.track_adapter_settings().max_aspect_ratio); |
| 792 CheckTrackAdapterSettingsEqualsFormat(result); |
649 | 793 |
650 constraint_factory_.basic().height.setMin(1200); | 794 constraint_factory_.basic().height.setMin(1200); |
651 constraint_factory_.basic().height.setMax(2000); | 795 constraint_factory_.basic().height.setMax(2000); |
652 result = SelectSettings(); | 796 result = SelectSettings(); |
653 EXPECT_TRUE(result.HasValue()); | 797 EXPECT_TRUE(result.HasValue()); |
654 EXPECT_EQ(kIdealWidth, result.Width()); | 798 EXPECT_EQ(kIdealWidth, result.Width()); |
655 // kIdealWidth / kDefaultAspectRatio outside the box. Closest is | 799 // kIdealWidth / kDefaultAspectRatio outside the box. Closest is |
656 // min height. | 800 // min height. |
657 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); | 801 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); |
658 CheckNonResolutionDefaults(result); | 802 CheckNonResolutionDefaults(result); |
| 803 EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio); |
| 804 EXPECT_EQ(1000.0 / 1200.0, |
| 805 result.track_adapter_settings().max_aspect_ratio); |
| 806 CheckTrackAdapterSettingsEqualsFormat(result); |
659 | 807 |
660 constraint_factory_.basic().height.setMin(100); | 808 constraint_factory_.basic().height.setMin(100); |
661 constraint_factory_.basic().height.setMax(500); | 809 constraint_factory_.basic().height.setMax(500); |
662 result = SelectSettings(); | 810 result = SelectSettings(); |
663 EXPECT_TRUE(result.HasValue()); | 811 EXPECT_TRUE(result.HasValue()); |
664 EXPECT_EQ(kIdealWidth, result.Width()); | 812 EXPECT_EQ(kIdealWidth, result.Width()); |
665 // kIdealWidth / kDefaultAspectRatio is outside the box. Closest is max | 813 // kIdealWidth / kDefaultAspectRatio is outside the box. Closest is max |
666 // height. | 814 // height. |
667 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 815 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
668 CheckNonResolutionDefaults(result); | 816 CheckNonResolutionDefaults(result); |
| 817 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 818 EXPECT_EQ(1000.0 / 100.0, result.track_adapter_settings().max_aspect_ratio); |
| 819 CheckTrackAdapterSettingsEqualsFormat(result); |
669 } | 820 } |
670 | 821 |
671 // Ideal outside the box, closest to the side coinciding with max width. | 822 // Ideal outside the box, closest to the side coinciding with max width. |
672 { | 823 { |
673 const int kMaxWidth = 1000; | 824 const int kMaxWidth = 1000; |
674 constraint_factory_.Reset(); | 825 constraint_factory_.Reset(); |
675 constraint_factory_.basic().width.setMin(500); | 826 constraint_factory_.basic().width.setMin(500); |
676 constraint_factory_.basic().width.setMax(kMaxWidth); | 827 constraint_factory_.basic().width.setMax(kMaxWidth); |
677 constraint_factory_.basic().height.setMin(100); | 828 constraint_factory_.basic().height.setMin(100); |
678 constraint_factory_.basic().height.setMax(500); | 829 constraint_factory_.basic().height.setMax(500); |
679 constraint_factory_.basic().width.setIdeal(1200); | 830 constraint_factory_.basic().width.setIdeal(1200); |
680 auto result = SelectSettings(); | 831 auto result = SelectSettings(); |
681 EXPECT_TRUE(result.HasValue()); | 832 EXPECT_TRUE(result.HasValue()); |
682 EXPECT_EQ(kMaxWidth, result.Width()); | 833 EXPECT_EQ(kMaxWidth, result.Width()); |
683 // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is max | 834 // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is max |
684 // height. | 835 // height. |
685 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 836 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
686 CheckNonResolutionDefaults(result); | 837 CheckNonResolutionDefaults(result); |
| 838 EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 839 EXPECT_EQ(static_cast<double>(kMaxWidth) / 100.0, |
| 840 result.track_adapter_settings().max_aspect_ratio); |
| 841 CheckTrackAdapterSettingsEqualsFormat(result); |
687 | 842 |
688 constraint_factory_.basic().height.setMin(1500); | 843 constraint_factory_.basic().height.setMin(1500); |
689 constraint_factory_.basic().height.setMax(2000); | 844 constraint_factory_.basic().height.setMax(2000); |
690 result = SelectSettings(); | 845 result = SelectSettings(); |
691 EXPECT_TRUE(result.HasValue()); | 846 EXPECT_TRUE(result.HasValue()); |
692 EXPECT_EQ(kMaxWidth, result.Width()); | 847 EXPECT_EQ(kMaxWidth, result.Width()); |
693 // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is | 848 // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is |
694 // min height. | 849 // min height. |
695 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); | 850 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); |
696 CheckNonResolutionDefaults(result); | 851 CheckNonResolutionDefaults(result); |
| 852 EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio); |
| 853 EXPECT_EQ(static_cast<double>(kMaxWidth) / 1500.0, |
| 854 result.track_adapter_settings().max_aspect_ratio); |
| 855 CheckTrackAdapterSettingsEqualsFormat(result); |
697 | 856 |
698 constraint_factory_.basic().height.setMin(100); | 857 constraint_factory_.basic().height.setMin(100); |
699 result = SelectSettings(); | 858 result = SelectSettings(); |
700 EXPECT_TRUE(result.HasValue()); | 859 EXPECT_TRUE(result.HasValue()); |
701 EXPECT_EQ(kMaxWidth, result.Width()); | 860 EXPECT_EQ(kMaxWidth, result.Width()); |
702 // kMaxWidth / kDefaultAspectRatio is within the height limits. | 861 // kMaxWidth / kDefaultAspectRatio is within the height limits. |
703 EXPECT_EQ( | 862 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio), |
704 std::round(kMaxWidth / MediaStreamVideoSource::kDefaultAspectRatio), | 863 result.Height()); |
705 result.Height()); | |
706 CheckNonResolutionDefaults(result); | 864 CheckNonResolutionDefaults(result); |
| 865 EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio); |
| 866 EXPECT_EQ(static_cast<double>(kMaxWidth) / 100.0, |
| 867 result.track_adapter_settings().max_aspect_ratio); |
| 868 CheckTrackAdapterSettingsEqualsFormat(result); |
707 } | 869 } |
708 | 870 |
709 // Ideal outside the constrained set, closest to a single point. | 871 // Ideal outside the constrained set, closest to a single point. |
710 { | 872 { |
711 constraint_factory_.Reset(); | 873 constraint_factory_.Reset(); |
712 constraint_factory_.basic().width.setMin(100); | 874 constraint_factory_.basic().width.setMin(100); |
713 constraint_factory_.basic().width.setMax(500); | 875 constraint_factory_.basic().width.setMax(500); |
714 constraint_factory_.basic().height.setMin(100); | 876 constraint_factory_.basic().height.setMin(100); |
715 constraint_factory_.basic().height.setMax(500); | 877 constraint_factory_.basic().height.setMax(500); |
716 constraint_factory_.basic().aspectRatio.setMax(1.0); | 878 constraint_factory_.basic().aspectRatio.setMax(1.0); |
717 constraint_factory_.basic().width.setIdeal(1200); | 879 constraint_factory_.basic().width.setIdeal(1200); |
718 auto result = SelectSettings(); | 880 auto result = SelectSettings(); |
719 EXPECT_TRUE(result.HasValue()); | 881 EXPECT_TRUE(result.HasValue()); |
720 // (max-width, max-height) is the single point closest to the ideal line. | 882 // (max-width, max-height) is the single point closest to the ideal line. |
721 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 883 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
722 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 884 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
723 CheckNonResolutionDefaults(result); | 885 CheckNonResolutionDefaults(result); |
| 886 EXPECT_EQ(100.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 887 EXPECT_EQ(1.0, result.track_adapter_settings().max_aspect_ratio); |
| 888 CheckTrackAdapterSettingsEqualsFormat(result); |
724 } | 889 } |
725 } | 890 } |
726 | 891 |
727 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactAspectRatio) { | 892 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactAspectRatio) { |
728 constraint_factory_.Reset(); | 893 constraint_factory_.Reset(); |
729 const double kAspectRatio = 2.0; | 894 const double kAspectRatio = 2.0; |
730 constraint_factory_.basic().aspectRatio.setExact(kAspectRatio); | 895 constraint_factory_.basic().aspectRatio.setExact(kAspectRatio); |
731 auto result = SelectSettings(); | 896 auto result = SelectSettings(); |
732 EXPECT_TRUE(result.HasValue()); | 897 EXPECT_TRUE(result.HasValue()); |
733 // Given that the default aspect ratio cannot be preserved, the algorithm | 898 // Given that the default aspect ratio cannot be preserved, the algorithm |
734 // tries to preserve, among the default height or width, the one that leads | 899 // tries to preserve, among the default height or width, the one that leads |
735 // to highest area. In this case, height is preserved. | 900 // to highest area. In this case, height is preserved. |
736 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 901 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
737 EXPECT_EQ(std::round(MediaStreamVideoSource::kDefaultHeight * kAspectRatio), | 902 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kAspectRatio), |
738 result.Width()); | 903 result.Width()); |
739 CheckNonResolutionDefaults(result); | 904 CheckNonResolutionDefaults(result); |
| 905 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().min_aspect_ratio); |
| 906 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().max_aspect_ratio); |
| 907 CheckTrackAdapterSettingsEqualsFormat(result); |
740 } | 908 } |
741 | 909 |
742 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinAspectRatio) { | 910 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinAspectRatio) { |
743 constraint_factory_.Reset(); | 911 constraint_factory_.Reset(); |
744 const double kAspectRatio = 2.0; | 912 const double kAspectRatio = 2.0; |
745 constraint_factory_.basic().aspectRatio.setMin(kAspectRatio); | 913 constraint_factory_.basic().aspectRatio.setMin(kAspectRatio); |
746 auto result = SelectSettings(); | 914 auto result = SelectSettings(); |
747 EXPECT_TRUE(result.HasValue()); | 915 EXPECT_TRUE(result.HasValue()); |
748 // kAspectRatio is greater that the default, so expect kAspectRatio. | 916 // kAspectRatio is greater that the default, so expect kAspectRatio. |
749 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 917 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
750 EXPECT_EQ(std::round(MediaStreamVideoSource::kDefaultHeight * kAspectRatio), | 918 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kAspectRatio), |
751 result.Width()); | 919 result.Width()); |
752 CheckNonResolutionDefaults(result); | 920 CheckNonResolutionDefaults(result); |
| 921 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().min_aspect_ratio); |
| 922 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / |
| 923 static_cast<double>(kMinScreenCastDimension), |
| 924 result.track_adapter_settings().max_aspect_ratio); |
| 925 CheckTrackAdapterSettingsEqualsFormat(result); |
753 | 926 |
754 const double kSmallAspectRatio = 0.5; | 927 const double kSmallAspectRatio = 0.5; |
755 constraint_factory_.basic().aspectRatio.setMin(kSmallAspectRatio); | 928 constraint_factory_.basic().aspectRatio.setMin(kSmallAspectRatio); |
756 result = SelectSettings(); | 929 result = SelectSettings(); |
757 EXPECT_TRUE(result.HasValue()); | 930 EXPECT_TRUE(result.HasValue()); |
758 // kSmallAspectRatio is less that the default, so expect the default. | 931 // kSmallAspectRatio is less that the default, so expect the default. |
759 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 932 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
760 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 933 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
761 CheckNonResolutionDefaults(result); | 934 CheckNonResolutionDefaults(result); |
| 935 EXPECT_EQ(kSmallAspectRatio, |
| 936 result.track_adapter_settings().min_aspect_ratio); |
| 937 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / |
| 938 static_cast<double>(kMinScreenCastDimension), |
| 939 result.track_adapter_settings().max_aspect_ratio); |
| 940 CheckTrackAdapterSettingsEqualsFormat(result); |
762 } | 941 } |
763 | 942 |
764 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxAspectRatio) { | 943 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxAspectRatio) { |
765 constraint_factory_.Reset(); | 944 constraint_factory_.Reset(); |
766 const double kAspectRatio = 2.0; | 945 const double kAspectRatio = 2.0; |
767 constraint_factory_.basic().aspectRatio.setMax(kAspectRatio); | 946 constraint_factory_.basic().aspectRatio.setMax(kAspectRatio); |
768 auto result = SelectSettings(); | 947 auto result = SelectSettings(); |
769 EXPECT_TRUE(result.HasValue()); | 948 EXPECT_TRUE(result.HasValue()); |
770 // kAspectRatio is greater that the default, so expect the default. | 949 // kAspectRatio is greater that the default, so expect the default. |
771 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 950 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
772 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 951 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
773 CheckNonResolutionDefaults(result); | 952 CheckNonResolutionDefaults(result); |
| 953 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / |
| 954 static_cast<double>(kMaxScreenCastDimension), |
| 955 result.track_adapter_settings().min_aspect_ratio); |
| 956 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().max_aspect_ratio); |
| 957 CheckTrackAdapterSettingsEqualsFormat(result); |
774 | 958 |
775 const double kSmallAspectRatio = 0.5; | 959 const double kSmallAspectRatio = 0.5; |
776 constraint_factory_.basic().aspectRatio.setMax(kSmallAspectRatio); | 960 constraint_factory_.basic().aspectRatio.setMax(kSmallAspectRatio); |
777 result = SelectSettings(); | 961 result = SelectSettings(); |
778 EXPECT_TRUE(result.HasValue()); | 962 EXPECT_TRUE(result.HasValue()); |
779 // kSmallAspectRatio is less that the default, so expect kSmallAspectRatio. | 963 // kSmallAspectRatio is less that the default, so expect kSmallAspectRatio. |
780 // Prefer to preserve default width since that leads to larger area than | 964 // Prefer to preserve default width since that leads to larger area than |
781 // preserving default height. | 965 // preserving default height. |
782 EXPECT_EQ( | 966 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kSmallAspectRatio), |
783 std::round(MediaStreamVideoSource::kDefaultWidth / kSmallAspectRatio), | 967 result.Height()); |
784 result.Height()); | 968 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
785 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | |
786 CheckNonResolutionDefaults(result); | 969 CheckNonResolutionDefaults(result); |
| 970 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / |
| 971 static_cast<double>(kMaxScreenCastDimension), |
| 972 result.track_adapter_settings().min_aspect_ratio); |
| 973 EXPECT_EQ(kSmallAspectRatio, |
| 974 result.track_adapter_settings().max_aspect_ratio); |
| 975 CheckTrackAdapterSettingsEqualsFormat(result); |
787 } | 976 } |
788 | 977 |
789 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeAspectRatio) { | 978 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeAspectRatio) { |
790 constraint_factory_.Reset(); | 979 constraint_factory_.Reset(); |
791 { | 980 { |
792 const double kMinAspectRatio = 0.5; | 981 const double kMinAspectRatio = 0.5; |
793 const double kMaxAspectRatio = 2.0; | 982 const double kMaxAspectRatio = 2.0; |
794 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); | 983 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); |
795 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); | 984 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); |
796 auto result = SelectSettings(); | 985 auto result = SelectSettings(); |
797 EXPECT_TRUE(result.HasValue()); | 986 EXPECT_TRUE(result.HasValue()); |
798 // Range includes default, so expect the default. | 987 // Range includes default, so expect the default. |
799 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 988 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
800 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 989 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
801 CheckNonResolutionDefaults(result); | 990 CheckNonResolutionDefaults(result); |
| 991 EXPECT_EQ(kMinAspectRatio, |
| 992 result.track_adapter_settings().min_aspect_ratio); |
| 993 EXPECT_EQ(kMaxAspectRatio, |
| 994 result.track_adapter_settings().max_aspect_ratio); |
| 995 CheckTrackAdapterSettingsEqualsFormat(result); |
802 } | 996 } |
803 | 997 |
804 { | 998 { |
805 const double kMinAspectRatio = 2.0; | 999 const double kMinAspectRatio = 2.0; |
806 const double kMaxAspectRatio = 3.0; | 1000 const double kMaxAspectRatio = 3.0; |
807 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); | 1001 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); |
808 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); | 1002 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); |
809 auto result = SelectSettings(); | 1003 auto result = SelectSettings(); |
810 EXPECT_TRUE(result.HasValue()); | 1004 EXPECT_TRUE(result.HasValue()); |
811 // The whole range is greater than the default. Expect the minimum. | 1005 // The whole range is greater than the default. Expect the minimum. |
812 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1006 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
813 EXPECT_EQ( | 1007 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio), |
814 std::round(MediaStreamVideoSource::kDefaultHeight * kMinAspectRatio), | 1008 result.Width()); |
815 result.Width()); | |
816 CheckNonResolutionDefaults(result); | 1009 CheckNonResolutionDefaults(result); |
| 1010 EXPECT_EQ(kMinAspectRatio, |
| 1011 result.track_adapter_settings().min_aspect_ratio); |
| 1012 EXPECT_EQ(kMaxAspectRatio, |
| 1013 result.track_adapter_settings().max_aspect_ratio); |
| 1014 CheckTrackAdapterSettingsEqualsFormat(result); |
817 } | 1015 } |
818 | 1016 |
819 { | 1017 { |
820 const double kMinAspectRatio = 0.5; | 1018 const double kMinAspectRatio = 0.5; |
821 const double kMaxAspectRatio = 1.0; | 1019 const double kMaxAspectRatio = 1.0; |
822 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); | 1020 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); |
823 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); | 1021 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); |
824 auto result = SelectSettings(); | 1022 auto result = SelectSettings(); |
825 EXPECT_TRUE(result.HasValue()); | 1023 EXPECT_TRUE(result.HasValue()); |
826 // The whole range is less than the default. Expect the maximum. | 1024 // The whole range is less than the default. Expect the maximum. |
827 EXPECT_EQ( | 1025 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMaxAspectRatio), |
828 std::round(MediaStreamVideoSource::kDefaultWidth / kMaxAspectRatio), | 1026 result.Height()); |
829 result.Height()); | 1027 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
830 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | |
831 CheckNonResolutionDefaults(result); | 1028 CheckNonResolutionDefaults(result); |
| 1029 EXPECT_EQ(kMinAspectRatio, |
| 1030 result.track_adapter_settings().min_aspect_ratio); |
| 1031 EXPECT_EQ(kMaxAspectRatio, |
| 1032 result.track_adapter_settings().max_aspect_ratio); |
| 1033 CheckTrackAdapterSettingsEqualsFormat(result); |
832 } | 1034 } |
833 } | 1035 } |
834 | 1036 |
835 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealAspectRatio) { | 1037 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealAspectRatio) { |
836 // Unconstrained. | 1038 // Unconstrained. |
837 { | 1039 { |
838 constraint_factory_.Reset(); | 1040 constraint_factory_.Reset(); |
839 const double kIdealAspectRatio = 2.0; | 1041 const double kIdealAspectRatio = 2.0; |
840 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); | 1042 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); |
841 auto result = SelectSettings(); | 1043 auto result = SelectSettings(); |
842 EXPECT_TRUE(result.HasValue()); | 1044 EXPECT_TRUE(result.HasValue()); |
843 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1045 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
844 EXPECT_EQ( | 1046 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kIdealAspectRatio), |
845 std::round(MediaStreamVideoSource::kDefaultHeight * kIdealAspectRatio), | 1047 result.Width()); |
846 result.Width()); | |
847 CheckNonResolutionDefaults(result); | 1048 CheckNonResolutionDefaults(result); |
| 1049 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
848 } | 1050 } |
849 | 1051 |
850 // Ideal greater than maximum. | 1052 // Ideal greater than maximum. |
851 { | 1053 { |
852 constraint_factory_.Reset(); | 1054 constraint_factory_.Reset(); |
853 const double kIdealAspectRatio = 2.0; | 1055 const double kIdealAspectRatio = 2.0; |
854 const double kMaxAspectRatio = 1.5; | 1056 const double kMaxAspectRatio = 1.5; |
855 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); | 1057 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); |
856 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); | 1058 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); |
857 auto result = SelectSettings(); | 1059 auto result = SelectSettings(); |
858 EXPECT_TRUE(result.HasValue()); | 1060 EXPECT_TRUE(result.HasValue()); |
859 // Ideal height is greater than the maximum, expect maximum. | 1061 // Ideal height is greater than the maximum, expect maximum. |
860 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1062 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
| 1063 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMaxAspectRatio), |
| 1064 result.Width()); |
| 1065 CheckNonResolutionDefaults(result); |
861 EXPECT_EQ( | 1066 EXPECT_EQ( |
862 std::round(MediaStreamVideoSource::kDefaultHeight * kMaxAspectRatio), | 1067 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension, |
863 result.Width()); | 1068 result.track_adapter_settings().min_aspect_ratio); |
864 CheckNonResolutionDefaults(result); | 1069 EXPECT_EQ(kMaxAspectRatio, |
| 1070 result.track_adapter_settings().max_aspect_ratio); |
| 1071 CheckTrackAdapterSettingsEqualsFormat(result); |
865 } | 1072 } |
866 | 1073 |
867 // Ideal less than minimum. | 1074 // Ideal less than minimum. |
868 { | 1075 { |
869 constraint_factory_.Reset(); | 1076 constraint_factory_.Reset(); |
870 const double kIdealAspectRatio = 1.0; | 1077 const double kIdealAspectRatio = 1.0; |
871 const double kMinAspectRatio = 1.5; | 1078 const double kMinAspectRatio = 1.5; |
872 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); | 1079 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); |
873 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); | 1080 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); |
874 auto result = SelectSettings(); | 1081 auto result = SelectSettings(); |
875 EXPECT_TRUE(result.HasValue()); | 1082 EXPECT_TRUE(result.HasValue()); |
876 // Ideal height is greater than the maximum, expect maximum. | 1083 // Ideal height is greater than the maximum, expect maximum. |
877 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1084 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
| 1085 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio), |
| 1086 result.Width()); |
| 1087 CheckNonResolutionDefaults(result); |
| 1088 EXPECT_EQ(kMinAspectRatio, |
| 1089 result.track_adapter_settings().min_aspect_ratio); |
878 EXPECT_EQ( | 1090 EXPECT_EQ( |
879 std::round(MediaStreamVideoSource::kDefaultHeight * kMinAspectRatio), | 1091 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
880 result.Width()); | 1092 result.track_adapter_settings().max_aspect_ratio); |
881 CheckNonResolutionDefaults(result); | 1093 CheckTrackAdapterSettingsEqualsFormat(result); |
882 } | 1094 } |
883 | 1095 |
884 // Ideal intersects a box. | 1096 // Ideal intersects a box. |
885 { | 1097 { |
886 constraint_factory_.Reset(); | 1098 constraint_factory_.Reset(); |
887 constraint_factory_.basic().height.setMin(100); | 1099 constraint_factory_.basic().height.setMin(100); |
888 constraint_factory_.basic().height.setMax(500); | 1100 constraint_factory_.basic().height.setMax(500); |
889 constraint_factory_.basic().width.setMin(100); | 1101 constraint_factory_.basic().width.setMin(100); |
890 constraint_factory_.basic().width.setMax(500); | 1102 constraint_factory_.basic().width.setMax(500); |
891 const int kIdealAspectRatio = 2.0; | 1103 const int kIdealAspectRatio = 2.0; |
892 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); | 1104 constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio); |
893 auto result = SelectSettings(); | 1105 auto result = SelectSettings(); |
894 EXPECT_TRUE(result.HasValue()); | 1106 EXPECT_TRUE(result.HasValue()); |
895 // Ideal aspect-ratio is included in the bounding box, with the value | 1107 // Ideal aspect-ratio is included in the bounding box, with the value |
896 // closest to a standard width or height being the cut with the maximum | 1108 // closest to a standard width or height being the cut with the maximum |
897 // width. | 1109 // width. |
898 EXPECT_EQ( | 1110 EXPECT_EQ( |
899 std::round(constraint_factory_.basic().width.max() / kIdealAspectRatio), | 1111 std::round(constraint_factory_.basic().width.max() / kIdealAspectRatio), |
900 result.Height()); | 1112 result.Height()); |
901 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 1113 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
902 CheckNonResolutionDefaults(result); | 1114 CheckNonResolutionDefaults(result); |
| 1115 EXPECT_EQ(100.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 1116 EXPECT_EQ(500.0 / 100.0, result.track_adapter_settings().max_aspect_ratio); |
| 1117 CheckTrackAdapterSettingsEqualsFormat(result); |
903 | 1118 |
904 constraint_factory_.basic().height.setMin(1000); | 1119 constraint_factory_.basic().height.setMin(1000); |
905 constraint_factory_.basic().height.setMax(5000); | 1120 constraint_factory_.basic().height.setMax(5000); |
906 constraint_factory_.basic().width.setMin(1000); | 1121 constraint_factory_.basic().width.setMin(1000); |
907 constraint_factory_.basic().width.setMax(5000); | 1122 constraint_factory_.basic().width.setMax(5000); |
908 result = SelectSettings(); | 1123 result = SelectSettings(); |
909 EXPECT_TRUE(result.HasValue()); | 1124 EXPECT_TRUE(result.HasValue()); |
910 // Ideal aspect-ratio is included in the bounding box, with the value | 1125 // Ideal aspect-ratio is included in the bounding box, with the value |
911 // closest to a standard width or height and largest area being the cut with | 1126 // closest to a standard width or height and largest area being the cut with |
912 // the minimum height. | 1127 // the minimum height. |
913 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); | 1128 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); |
914 EXPECT_EQ(std::round(constraint_factory_.basic().height.min() * | 1129 EXPECT_EQ(std::round(constraint_factory_.basic().height.min() * |
915 kIdealAspectRatio), | 1130 kIdealAspectRatio), |
916 result.Width()); | 1131 result.Width()); |
917 CheckNonResolutionDefaults(result); | 1132 CheckNonResolutionDefaults(result); |
| 1133 EXPECT_EQ(1000.0 / 5000.0, |
| 1134 result.track_adapter_settings().min_aspect_ratio); |
| 1135 EXPECT_EQ(5000.0 / 1000.0, |
| 1136 result.track_adapter_settings().max_aspect_ratio); |
| 1137 CheckTrackAdapterSettingsEqualsFormat(result); |
918 | 1138 |
919 constraint_factory_.basic().height.setMin(250); | 1139 constraint_factory_.basic().height.setMin(250); |
920 constraint_factory_.basic().height.setMax(5000); | 1140 constraint_factory_.basic().height.setMax(5000); |
921 constraint_factory_.basic().width.setMin(250); | 1141 constraint_factory_.basic().width.setMin(250); |
922 constraint_factory_.basic().width.setMax(5000); | 1142 constraint_factory_.basic().width.setMax(5000); |
923 result = SelectSettings(); | 1143 result = SelectSettings(); |
924 EXPECT_TRUE(result.HasValue()); | 1144 EXPECT_TRUE(result.HasValue()); |
925 // Ideal aspect-ratio and default width and height are included in the | 1145 // Ideal aspect-ratio and default width and height are included in the |
926 // bounding box. Preserving default height leads to larger area than | 1146 // bounding box. Preserving default height leads to larger area than |
927 // preserving default width. | 1147 // preserving default width. |
928 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1148 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
929 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight * kIdealAspectRatio, | 1149 EXPECT_EQ(kDefaultScreenCastHeight * kIdealAspectRatio, result.Width()); |
930 result.Width()); | |
931 CheckNonResolutionDefaults(result); | 1150 CheckNonResolutionDefaults(result); |
| 1151 EXPECT_EQ(250.0 / 5000.0, result.track_adapter_settings().min_aspect_ratio); |
| 1152 EXPECT_EQ(5000.0 / 250.0, result.track_adapter_settings().max_aspect_ratio); |
| 1153 CheckTrackAdapterSettingsEqualsFormat(result); |
932 } | 1154 } |
933 | 1155 |
934 // Ideal outside the constrained area, closest to min or max aspect ratio. | 1156 // Ideal outside the constrained area, closest to min or max aspect ratio. |
935 { | 1157 { |
936 const double kMinAspectRatio = 0.5; | 1158 const double kMinAspectRatio = 0.5; |
937 const double kMaxAspectRatio = 2.0; | 1159 const double kMaxAspectRatio = 2.0; |
938 constraint_factory_.Reset(); | 1160 constraint_factory_.Reset(); |
939 constraint_factory_.basic().height.setMin(100); | 1161 constraint_factory_.basic().height.setMin(100); |
940 constraint_factory_.basic().height.setMax(500); | 1162 constraint_factory_.basic().height.setMax(500); |
941 constraint_factory_.basic().width.setMin(100); | 1163 constraint_factory_.basic().width.setMin(100); |
942 constraint_factory_.basic().width.setMax(500); | 1164 constraint_factory_.basic().width.setMax(500); |
943 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); | 1165 constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio); |
944 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); | 1166 constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio); |
945 constraint_factory_.basic().aspectRatio.setIdeal(3.0); | 1167 constraint_factory_.basic().aspectRatio.setIdeal(3.0); |
946 auto result = SelectSettings(); | 1168 auto result = SelectSettings(); |
947 EXPECT_TRUE(result.HasValue()); | 1169 EXPECT_TRUE(result.HasValue()); |
948 // Ideal is closest to kMaxAspectRatio. | 1170 // Ideal is closest to kMaxAspectRatio. |
949 EXPECT_EQ( | 1171 EXPECT_EQ( |
950 std::round(constraint_factory_.basic().width.max() / kMaxAspectRatio), | 1172 std::round(constraint_factory_.basic().width.max() / kMaxAspectRatio), |
951 result.Height()); | 1173 result.Height()); |
952 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 1174 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
953 CheckNonResolutionDefaults(result); | 1175 CheckNonResolutionDefaults(result); |
| 1176 EXPECT_EQ(kMinAspectRatio, |
| 1177 result.track_adapter_settings().min_aspect_ratio); |
| 1178 EXPECT_EQ(kMaxAspectRatio, |
| 1179 result.track_adapter_settings().max_aspect_ratio); |
| 1180 CheckTrackAdapterSettingsEqualsFormat(result); |
954 | 1181 |
955 constraint_factory_.basic().aspectRatio.setIdeal(0.3); | 1182 constraint_factory_.basic().aspectRatio.setIdeal(0.3); |
956 result = SelectSettings(); | 1183 result = SelectSettings(); |
957 EXPECT_TRUE(result.HasValue()); | 1184 EXPECT_TRUE(result.HasValue()); |
958 // Ideal is closest to kMinAspectRatio. | 1185 // Ideal is closest to kMinAspectRatio. |
959 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); | 1186 EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height()); |
960 EXPECT_EQ( | 1187 EXPECT_EQ( |
961 std::round(constraint_factory_.basic().height.max() * kMinAspectRatio), | 1188 std::round(constraint_factory_.basic().height.max() * kMinAspectRatio), |
962 result.Width()); | 1189 result.Width()); |
963 CheckNonResolutionDefaults(result); | 1190 CheckNonResolutionDefaults(result); |
| 1191 EXPECT_EQ(kMinAspectRatio, |
| 1192 result.track_adapter_settings().min_aspect_ratio); |
| 1193 EXPECT_EQ(kMaxAspectRatio, |
| 1194 result.track_adapter_settings().max_aspect_ratio); |
| 1195 CheckTrackAdapterSettingsEqualsFormat(result); |
964 | 1196 |
965 // Use a box that is bigger and further from the origin to force closeness | 1197 // Use a box that is bigger and further from the origin to force closeness |
966 // to a different default dimension. | 1198 // to a different default dimension. |
967 constraint_factory_.basic().height.setMin(1000); | 1199 constraint_factory_.basic().height.setMin(1000); |
968 constraint_factory_.basic().height.setMax(5000); | 1200 constraint_factory_.basic().height.setMax(5000); |
969 constraint_factory_.basic().width.setMin(1000); | 1201 constraint_factory_.basic().width.setMin(1000); |
970 constraint_factory_.basic().width.setMax(5000); | 1202 constraint_factory_.basic().width.setMax(5000); |
971 constraint_factory_.basic().aspectRatio.setIdeal(3.0); | 1203 constraint_factory_.basic().aspectRatio.setIdeal(3.0); |
972 result = SelectSettings(); | 1204 result = SelectSettings(); |
973 EXPECT_TRUE(result.HasValue()); | 1205 EXPECT_TRUE(result.HasValue()); |
974 // Ideal is closest to kMaxAspectRatio. | 1206 // Ideal is closest to kMaxAspectRatio. |
975 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); | 1207 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); |
976 EXPECT_EQ( | 1208 EXPECT_EQ( |
977 std::round(constraint_factory_.basic().height.min() * kMaxAspectRatio), | 1209 std::round(constraint_factory_.basic().height.min() * kMaxAspectRatio), |
978 result.Width()); | 1210 result.Width()); |
979 CheckNonResolutionDefaults(result); | 1211 CheckNonResolutionDefaults(result); |
| 1212 EXPECT_EQ(kMinAspectRatio, |
| 1213 result.track_adapter_settings().min_aspect_ratio); |
| 1214 EXPECT_EQ(kMaxAspectRatio, |
| 1215 result.track_adapter_settings().max_aspect_ratio); |
| 1216 CheckTrackAdapterSettingsEqualsFormat(result); |
980 | 1217 |
981 constraint_factory_.basic().aspectRatio.setIdeal(0.3); | 1218 constraint_factory_.basic().aspectRatio.setIdeal(0.3); |
982 result = SelectSettings(); | 1219 result = SelectSettings(); |
983 EXPECT_TRUE(result.HasValue()); | 1220 EXPECT_TRUE(result.HasValue()); |
984 // Ideal is closest to kMinAspectRatio. | 1221 // Ideal is closest to kMinAspectRatio. |
985 EXPECT_EQ( | 1222 EXPECT_EQ( |
986 std::round(constraint_factory_.basic().width.min() / kMinAspectRatio), | 1223 std::round(constraint_factory_.basic().width.min() / kMinAspectRatio), |
987 result.Height()); | 1224 result.Height()); |
988 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); | 1225 EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width()); |
989 CheckNonResolutionDefaults(result); | 1226 CheckNonResolutionDefaults(result); |
| 1227 EXPECT_EQ(kMinAspectRatio, |
| 1228 result.track_adapter_settings().min_aspect_ratio); |
| 1229 EXPECT_EQ(kMaxAspectRatio, |
| 1230 result.track_adapter_settings().max_aspect_ratio); |
| 1231 CheckTrackAdapterSettingsEqualsFormat(result); |
990 } | 1232 } |
991 | 1233 |
992 // Ideal outside the constrained area, closest to a single point. | 1234 // Ideal outside the constrained area, closest to a single point. |
993 { | 1235 { |
994 constraint_factory_.Reset(); | 1236 constraint_factory_.Reset(); |
995 constraint_factory_.basic().height.setMin(100); | 1237 constraint_factory_.basic().height.setMin(100); |
996 constraint_factory_.basic().height.setMax(500); | 1238 constraint_factory_.basic().height.setMax(500); |
997 constraint_factory_.basic().width.setMin(100); | 1239 constraint_factory_.basic().width.setMin(100); |
998 constraint_factory_.basic().width.setMax(500); | 1240 constraint_factory_.basic().width.setMax(500); |
999 constraint_factory_.basic().aspectRatio.setMin(1.0); | 1241 constraint_factory_.basic().aspectRatio.setMin(1.0); |
1000 constraint_factory_.basic().aspectRatio.setIdeal(10.0); | 1242 constraint_factory_.basic().aspectRatio.setIdeal(10.0); |
1001 auto result = SelectSettings(); | 1243 auto result = SelectSettings(); |
1002 EXPECT_TRUE(result.HasValue()); | 1244 EXPECT_TRUE(result.HasValue()); |
1003 // Ideal is closest to the min height and max width. | 1245 // Ideal is closest to the min height and max width. |
1004 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); | 1246 EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height()); |
1005 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); | 1247 EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width()); |
1006 CheckNonResolutionDefaults(result); | 1248 CheckNonResolutionDefaults(result); |
| 1249 EXPECT_EQ(1.0, result.track_adapter_settings().min_aspect_ratio); |
| 1250 EXPECT_EQ(500.0 / 100.0, result.track_adapter_settings().max_aspect_ratio); |
| 1251 CheckTrackAdapterSettingsEqualsFormat(result); |
1007 } | 1252 } |
1008 } | 1253 } |
1009 | 1254 |
1010 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactFrameRate) { | 1255 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactFrameRate) { |
1011 constraint_factory_.Reset(); | 1256 constraint_factory_.Reset(); |
1012 const int kFrameRate = 45.0; | 1257 const int kFrameRate = 45.0; |
1013 constraint_factory_.basic().frameRate.setExact(kFrameRate); | 1258 constraint_factory_.basic().frameRate.setExact(kFrameRate); |
1014 auto result = SelectSettings(); | 1259 auto result = SelectSettings(); |
1015 EXPECT_TRUE(result.HasValue()); | 1260 EXPECT_TRUE(result.HasValue()); |
1016 EXPECT_EQ(kFrameRate, result.FrameRate()); | 1261 EXPECT_EQ(kFrameRate, result.FrameRate()); |
1017 CheckNonFrameRateDefaults(result); | 1262 CheckNonFrameRateDefaults(result); |
| 1263 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1018 } | 1264 } |
1019 | 1265 |
1020 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinFrameRate) { | 1266 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinFrameRate) { |
1021 constraint_factory_.Reset(); | 1267 constraint_factory_.Reset(); |
1022 const double kFrameRate = 45.0; | 1268 const double kFrameRate = 45.0; |
1023 constraint_factory_.basic().frameRate.setMin(kFrameRate); | 1269 constraint_factory_.basic().frameRate.setMin(kFrameRate); |
1024 auto result = SelectSettings(); | 1270 auto result = SelectSettings(); |
1025 EXPECT_TRUE(result.HasValue()); | 1271 EXPECT_TRUE(result.HasValue()); |
1026 // kFrameRate is greater that the default, so expect kFrameRate. | 1272 // kFrameRate is greater that the default, so expect kFrameRate. |
1027 EXPECT_EQ(kFrameRate, result.FrameRate()); | 1273 EXPECT_EQ(kFrameRate, result.FrameRate()); |
1028 CheckNonFrameRateDefaults(result); | 1274 CheckNonFrameRateDefaults(result); |
| 1275 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1029 | 1276 |
1030 const double kSmallFrameRate = 5.0; | 1277 const double kSmallFrameRate = 5.0; |
1031 constraint_factory_.basic().frameRate.setMin(kSmallFrameRate); | 1278 constraint_factory_.basic().frameRate.setMin(kSmallFrameRate); |
1032 result = SelectSettings(); | 1279 result = SelectSettings(); |
1033 EXPECT_TRUE(result.HasValue()); | 1280 EXPECT_TRUE(result.HasValue()); |
1034 // kFrameRate is greater that the default, so expect kFrameRate. | 1281 // kFrameRate is greater that the default, so expect kFrameRate. |
1035 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1282 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
1036 CheckNonFrameRateDefaults(result); | 1283 CheckNonFrameRateDefaults(result); |
| 1284 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1037 } | 1285 } |
1038 | 1286 |
1039 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxFrameRate) { | 1287 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxFrameRate) { |
1040 constraint_factory_.Reset(); | 1288 constraint_factory_.Reset(); |
1041 const double kFrameRate = 45.0; | 1289 const double kFrameRate = 45.0; |
1042 constraint_factory_.basic().frameRate.setMax(kFrameRate); | 1290 constraint_factory_.basic().frameRate.setMax(kFrameRate); |
1043 auto result = SelectSettings(); | 1291 auto result = SelectSettings(); |
1044 EXPECT_TRUE(result.HasValue()); | 1292 EXPECT_TRUE(result.HasValue()); |
1045 // kFrameRate is greater that the default, so expect the default. | 1293 // kFrameRate is greater that the default, so expect the default. |
1046 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1294 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
1047 CheckNonFrameRateDefaults(result); | 1295 CheckNonFrameRateDefaults(result); |
| 1296 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1048 | 1297 |
1049 const double kSmallFrameRate = 5.0; | 1298 const double kSmallFrameRate = 5.0; |
1050 constraint_factory_.basic().frameRate.setMax(kSmallFrameRate); | 1299 constraint_factory_.basic().frameRate.setMax(kSmallFrameRate); |
1051 result = SelectSettings(); | 1300 result = SelectSettings(); |
1052 EXPECT_TRUE(result.HasValue()); | 1301 EXPECT_TRUE(result.HasValue()); |
1053 // kFrameRate is less that the default, so expect kFrameRate. | 1302 // kFrameRate is less that the default, so expect kFrameRate. |
1054 EXPECT_EQ(kSmallFrameRate, result.FrameRate()); | 1303 EXPECT_EQ(kSmallFrameRate, result.FrameRate()); |
1055 CheckNonFrameRateDefaults(result); | 1304 CheckNonFrameRateDefaults(result); |
| 1305 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1056 } | 1306 } |
1057 | 1307 |
1058 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeFrameRate) { | 1308 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeFrameRate) { |
1059 constraint_factory_.Reset(); | 1309 constraint_factory_.Reset(); |
1060 { | 1310 { |
1061 const double kMinFrameRate = 15.0; | 1311 const double kMinFrameRate = 15.0; |
1062 const double kMaxFrameRate = 45.0; | 1312 const double kMaxFrameRate = 45.0; |
1063 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); | 1313 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); |
1064 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); | 1314 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); |
1065 auto result = SelectSettings(); | 1315 auto result = SelectSettings(); |
1066 EXPECT_TRUE(result.HasValue()); | 1316 EXPECT_TRUE(result.HasValue()); |
1067 // The range includes the default, so expect the default. | 1317 // The range includes the default, so expect the default. |
1068 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1318 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
1069 CheckNonFrameRateDefaults(result); | 1319 CheckNonFrameRateDefaults(result); |
| 1320 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1070 } | 1321 } |
1071 | 1322 |
1072 { | 1323 { |
1073 const double kMinFrameRate = 45.0; | 1324 const double kMinFrameRate = 45.0; |
1074 const double kMaxFrameRate = 55.0; | 1325 const double kMaxFrameRate = 55.0; |
1075 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); | 1326 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); |
1076 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); | 1327 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); |
1077 auto result = SelectSettings(); | 1328 auto result = SelectSettings(); |
1078 EXPECT_TRUE(result.HasValue()); | 1329 EXPECT_TRUE(result.HasValue()); |
1079 // The whole range is greater that the default, so expect the minimum. | 1330 // The whole range is greater that the default, so expect the minimum. |
1080 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1331 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
1081 CheckNonFrameRateDefaults(result); | 1332 CheckNonFrameRateDefaults(result); |
| 1333 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1082 } | 1334 } |
1083 | 1335 |
1084 { | 1336 { |
1085 const double kMinFrameRate = 10.0; | 1337 const double kMinFrameRate = 10.0; |
1086 const double kMaxFrameRate = 15.0; | 1338 const double kMaxFrameRate = 15.0; |
1087 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); | 1339 constraint_factory_.basic().frameRate.setMax(kMinFrameRate); |
1088 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); | 1340 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); |
1089 auto result = SelectSettings(); | 1341 auto result = SelectSettings(); |
1090 EXPECT_TRUE(result.HasValue()); | 1342 EXPECT_TRUE(result.HasValue()); |
1091 // The whole range is less that the default, so expect the maximum. | 1343 // The whole range is less that the default, so expect the maximum. |
1092 EXPECT_EQ(kMaxFrameRate, result.FrameRate()); | 1344 EXPECT_EQ(kMaxFrameRate, result.FrameRate()); |
1093 CheckNonFrameRateDefaults(result); | 1345 CheckNonFrameRateDefaults(result); |
| 1346 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1094 } | 1347 } |
1095 } | 1348 } |
1096 | 1349 |
1097 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealFrameRate) { | 1350 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealFrameRate) { |
1098 // Unconstrained. | 1351 // Unconstrained. |
1099 { | 1352 { |
1100 constraint_factory_.Reset(); | 1353 constraint_factory_.Reset(); |
1101 const int kIdealFrameRate = 45.0; | 1354 const int kIdealFrameRate = 45.0; |
1102 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); | 1355 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); |
1103 auto result = SelectSettings(); | 1356 auto result = SelectSettings(); |
1104 EXPECT_TRUE(result.HasValue()); | 1357 EXPECT_TRUE(result.HasValue()); |
1105 EXPECT_EQ(kIdealFrameRate, result.FrameRate()); | 1358 EXPECT_EQ(kIdealFrameRate, result.FrameRate()); |
1106 CheckNonFrameRateDefaults(result); | 1359 CheckNonFrameRateDefaults(result); |
| 1360 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1107 } | 1361 } |
1108 | 1362 |
1109 // Ideal greater than maximum. | 1363 // Ideal greater than maximum. |
1110 { | 1364 { |
1111 constraint_factory_.Reset(); | 1365 constraint_factory_.Reset(); |
1112 const int kIdealFrameRate = 45.0; | 1366 const int kIdealFrameRate = 45.0; |
1113 const int kMaxFrameRate = 30.0; | 1367 const int kMaxFrameRate = 30.0; |
1114 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); | 1368 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); |
1115 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); | 1369 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); |
1116 auto result = SelectSettings(); | 1370 auto result = SelectSettings(); |
1117 EXPECT_TRUE(result.HasValue()); | 1371 EXPECT_TRUE(result.HasValue()); |
1118 EXPECT_EQ(kMaxFrameRate, result.FrameRate()); | 1372 EXPECT_EQ(kMaxFrameRate, result.FrameRate()); |
1119 CheckNonFrameRateDefaults(result); | 1373 CheckNonFrameRateDefaults(result); |
| 1374 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1120 } | 1375 } |
1121 | 1376 |
1122 // Ideal less than minimum. | 1377 // Ideal less than minimum. |
1123 { | 1378 { |
1124 constraint_factory_.Reset(); | 1379 constraint_factory_.Reset(); |
1125 const int kIdealFrameRate = 45.0; | 1380 const int kIdealFrameRate = 45.0; |
1126 const int kMinFrameRate = 50.0; | 1381 const int kMinFrameRate = 50.0; |
1127 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); | 1382 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); |
1128 constraint_factory_.basic().frameRate.setMin(kMinFrameRate); | 1383 constraint_factory_.basic().frameRate.setMin(kMinFrameRate); |
1129 auto result = SelectSettings(); | 1384 auto result = SelectSettings(); |
1130 EXPECT_TRUE(result.HasValue()); | 1385 EXPECT_TRUE(result.HasValue()); |
1131 EXPECT_EQ(kMinFrameRate, result.FrameRate()); | 1386 EXPECT_EQ(kMinFrameRate, result.FrameRate()); |
1132 CheckNonFrameRateDefaults(result); | 1387 CheckNonFrameRateDefaults(result); |
| 1388 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1133 } | 1389 } |
1134 | 1390 |
1135 // Ideal within range. | 1391 // Ideal within range. |
1136 { | 1392 { |
1137 constraint_factory_.Reset(); | 1393 constraint_factory_.Reset(); |
1138 const int kIdealFrameRate = 45.0; | 1394 const int kIdealFrameRate = 45.0; |
1139 const int kMinFrameRate = 35.0; | 1395 const int kMinFrameRate = 35.0; |
1140 const int kMaxFrameRate = 50.0; | 1396 const int kMaxFrameRate = 50.0; |
1141 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); | 1397 constraint_factory_.basic().frameRate.setIdeal(kIdealFrameRate); |
1142 constraint_factory_.basic().frameRate.setMin(kMinFrameRate); | 1398 constraint_factory_.basic().frameRate.setMin(kMinFrameRate); |
1143 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); | 1399 constraint_factory_.basic().frameRate.setMax(kMaxFrameRate); |
1144 auto result = SelectSettings(); | 1400 auto result = SelectSettings(); |
1145 EXPECT_TRUE(result.HasValue()); | 1401 EXPECT_TRUE(result.HasValue()); |
1146 EXPECT_EQ(kIdealFrameRate, result.FrameRate()); | 1402 EXPECT_EQ(kIdealFrameRate, result.FrameRate()); |
1147 CheckNonFrameRateDefaults(result); | 1403 CheckNonFrameRateDefaults(result); |
| 1404 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1148 } | 1405 } |
1149 } | 1406 } |
1150 | 1407 |
1151 // The "Advanced" tests check selection criteria involving advanced constraint | 1408 // The "Advanced" tests check selection criteria involving advanced constraint |
1152 // sets. | 1409 // sets. |
1153 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1410 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1154 AdvancedMinMaxResolutionFrameRate) { | 1411 AdvancedMinMaxResolutionFrameRate) { |
1155 constraint_factory_.Reset(); | 1412 constraint_factory_.Reset(); |
1156 blink::WebMediaTrackConstraintSet& advanced1 = | 1413 blink::WebMediaTrackConstraintSet& advanced1 = |
1157 constraint_factory_.AddAdvanced(); | 1414 constraint_factory_.AddAdvanced(); |
1158 advanced1.width.setMin(2000000000); | 1415 advanced1.width.setMin(2000000000); |
1159 advanced1.height.setMin(2000000000); | 1416 advanced1.height.setMin(2000000000); |
1160 // The first advanced set cannot be satisfied and is therefore ignored in all | 1417 // The first advanced set cannot be satisfied and is therefore ignored in all |
1161 // calls to SelectSettings(). | 1418 // calls to SelectSettings(). |
1162 // In this case, default settings must be selected. | 1419 // In this case, default settings must be selected. |
1163 auto result = SelectSettings(); | 1420 auto result = SelectSettings(); |
1164 EXPECT_TRUE(result.HasValue()); | 1421 EXPECT_TRUE(result.HasValue()); |
1165 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1422 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1166 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 1423 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
1167 CheckNonResolutionDefaults(result); | 1424 CheckNonResolutionDefaults(result); |
| 1425 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1168 | 1426 |
1169 blink::WebMediaTrackConstraintSet& advanced2 = | 1427 blink::WebMediaTrackConstraintSet& advanced2 = |
1170 constraint_factory_.AddAdvanced(); | 1428 constraint_factory_.AddAdvanced(); |
1171 advanced2.height.setMax(400); | 1429 advanced2.height.setMax(400); |
1172 advanced2.width.setMax(500); | 1430 advanced2.width.setMax(500); |
1173 advanced2.aspectRatio.setExact(5.0 / 4.0); | 1431 advanced2.aspectRatio.setExact(5.0 / 4.0); |
1174 result = SelectSettings(); | 1432 result = SelectSettings(); |
1175 EXPECT_TRUE(result.HasValue()); | 1433 EXPECT_TRUE(result.HasValue()); |
1176 EXPECT_EQ(400, result.Height()); | 1434 EXPECT_EQ(400, result.Height()); |
1177 EXPECT_EQ(500, result.Width()); | 1435 EXPECT_EQ(500, result.Width()); |
1178 CheckNonResolutionDefaults(result); | 1436 CheckNonResolutionDefaults(result); |
| 1437 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio); |
| 1438 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio); |
| 1439 CheckTrackAdapterSettingsEqualsFormat(result); |
1179 | 1440 |
1180 blink::WebMediaTrackConstraintSet& advanced3 = | 1441 blink::WebMediaTrackConstraintSet& advanced3 = |
1181 constraint_factory_.AddAdvanced(); | 1442 constraint_factory_.AddAdvanced(); |
1182 advanced3.frameRate.setMax(10.0); | 1443 advanced3.frameRate.setMax(10.0); |
1183 result = SelectSettings(); | 1444 result = SelectSettings(); |
1184 EXPECT_TRUE(result.HasValue()); | 1445 EXPECT_TRUE(result.HasValue()); |
1185 // The third advanced set is supported in addition to the previous set. | 1446 // The third advanced set is supported in addition to the previous set. |
1186 EXPECT_EQ(400, result.Height()); | 1447 EXPECT_EQ(400, result.Height()); |
1187 EXPECT_EQ(500, result.Width()); | 1448 EXPECT_EQ(500, result.Width()); |
1188 EXPECT_EQ(10.0, result.FrameRate()); | 1449 EXPECT_EQ(10.0, result.FrameRate()); |
1189 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 1450 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
1190 EXPECT_EQ(std::string(), result.device_id()); | 1451 EXPECT_EQ(std::string(), result.device_id()); |
| 1452 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio); |
| 1453 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio); |
| 1454 CheckTrackAdapterSettingsEqualsFormat(result); |
1191 | 1455 |
1192 blink::WebMediaTrackConstraintSet& advanced4 = | 1456 blink::WebMediaTrackConstraintSet& advanced4 = |
1193 constraint_factory_.AddAdvanced(); | 1457 constraint_factory_.AddAdvanced(); |
1194 advanced4.width.setExact(1000); | 1458 advanced4.width.setExact(1000); |
1195 advanced4.height.setExact(1000); | 1459 advanced4.height.setExact(1000); |
1196 result = SelectSettings(); | 1460 result = SelectSettings(); |
1197 // The fourth advanced set cannot be supported in combination with the | 1461 // The fourth advanced set cannot be supported in combination with the |
1198 // previous two sets, so it must be ignored. | 1462 // previous two sets, so it must be ignored. |
1199 EXPECT_TRUE(result.HasValue()); | 1463 EXPECT_TRUE(result.HasValue()); |
1200 EXPECT_EQ(400, result.Height()); | 1464 EXPECT_EQ(400, result.Height()); |
1201 EXPECT_EQ(500, result.Width()); | 1465 EXPECT_EQ(500, result.Width()); |
1202 EXPECT_EQ(10.0, result.FrameRate()); | 1466 EXPECT_EQ(10.0, result.FrameRate()); |
1203 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 1467 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
1204 EXPECT_EQ(std::string(), result.device_id()); | 1468 EXPECT_EQ(std::string(), result.device_id()); |
| 1469 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio); |
| 1470 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio); |
| 1471 CheckTrackAdapterSettingsEqualsFormat(result); |
1205 | 1472 |
1206 constraint_factory_.basic().width.setIdeal(100); | 1473 constraint_factory_.basic().width.setIdeal(100); |
1207 constraint_factory_.basic().height.setIdeal(100); | 1474 constraint_factory_.basic().height.setIdeal(100); |
1208 result = SelectSettings(); | 1475 result = SelectSettings(); |
1209 EXPECT_TRUE(result.HasValue()); | 1476 EXPECT_TRUE(result.HasValue()); |
1210 // The closest point to (100, 100) that satisfies all previous constraint | 1477 // The closest point to (100, 100) that satisfies all previous constraint |
1211 // sets is its projection on the aspect-ratio line 5.0/4.0. | 1478 // sets is its projection on the aspect-ratio line 5.0/4.0. |
1212 // This is a point m*(4, 5) such that Dot((4,5), (100 - m(4,5))) == 0. | 1479 // This is a point m*(4, 5) such that Dot((4,5), (100 - m(4,5))) == 0. |
1213 // This works out to be m = 900/41. | 1480 // This works out to be m = 900/41. |
1214 EXPECT_EQ(std::round(4.0 * 900.0 / 41.0), result.Height()); | 1481 EXPECT_EQ(std::round(4.0 * 900.0 / 41.0), result.Height()); |
1215 EXPECT_EQ(std::round(5.0 * 900.0 / 41.0), result.Width()); | 1482 EXPECT_EQ(std::round(5.0 * 900.0 / 41.0), result.Width()); |
1216 EXPECT_EQ(10.0, result.FrameRate()); | 1483 EXPECT_EQ(10.0, result.FrameRate()); |
1217 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 1484 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
1218 EXPECT_EQ(std::string(), result.device_id()); | 1485 EXPECT_EQ(std::string(), result.device_id()); |
| 1486 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio); |
| 1487 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio); |
| 1488 CheckTrackAdapterSettingsEqualsFormat(result); |
1219 | 1489 |
1220 constraint_factory_.basic().width.setIdeal(2000); | 1490 constraint_factory_.basic().width.setIdeal(2000); |
1221 constraint_factory_.basic().height.setIdeal(1500); | 1491 constraint_factory_.basic().height.setIdeal(1500); |
1222 result = SelectSettings(); | 1492 result = SelectSettings(); |
1223 EXPECT_TRUE(result.HasValue()); | 1493 EXPECT_TRUE(result.HasValue()); |
1224 // The projection of (2000,1500) on the aspect-ratio line 5.0/4.0 is beyond | 1494 // The projection of (2000,1500) on the aspect-ratio line 5.0/4.0 is beyond |
1225 // the maximum of (400, 500), so use the maximum allowed resolution. | 1495 // the maximum of (400, 500), so use the maximum allowed resolution. |
1226 EXPECT_TRUE(result.HasValue()); | 1496 EXPECT_TRUE(result.HasValue()); |
1227 EXPECT_EQ(400, result.Height()); | 1497 EXPECT_EQ(400, result.Height()); |
1228 EXPECT_EQ(500, result.Width()); | 1498 EXPECT_EQ(500, result.Width()); |
1229 EXPECT_EQ(10.0, result.FrameRate()); | 1499 EXPECT_EQ(10.0, result.FrameRate()); |
1230 EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction()); | 1500 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction()); |
1231 EXPECT_EQ(std::string(), result.device_id()); | 1501 EXPECT_EQ(std::string(), result.device_id()); |
| 1502 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio); |
| 1503 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio); |
| 1504 CheckTrackAdapterSettingsEqualsFormat(result); |
1232 } | 1505 } |
1233 | 1506 |
1234 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedExactResolution) { | 1507 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedExactResolution) { |
1235 { | 1508 { |
1236 constraint_factory_.Reset(); | 1509 constraint_factory_.Reset(); |
1237 blink::WebMediaTrackConstraintSet& advanced1 = | 1510 blink::WebMediaTrackConstraintSet& advanced1 = |
1238 constraint_factory_.AddAdvanced(); | 1511 constraint_factory_.AddAdvanced(); |
1239 advanced1.width.setExact(40000000); | 1512 advanced1.width.setExact(40000000); |
1240 advanced1.height.setExact(40000000); | 1513 advanced1.height.setExact(40000000); |
1241 blink::WebMediaTrackConstraintSet& advanced2 = | 1514 blink::WebMediaTrackConstraintSet& advanced2 = |
1242 constraint_factory_.AddAdvanced(); | 1515 constraint_factory_.AddAdvanced(); |
1243 advanced2.width.setExact(300000000); | 1516 advanced2.width.setExact(300000000); |
1244 advanced2.height.setExact(300000000); | 1517 advanced2.height.setExact(300000000); |
1245 auto result = SelectSettings(); | 1518 auto result = SelectSettings(); |
1246 // None of the constraint sets can be satisfied. Default resolution should | 1519 // None of the constraint sets can be satisfied. Default resolution should |
1247 // be selected. | 1520 // be selected. |
1248 EXPECT_TRUE(result.HasValue()); | 1521 EXPECT_TRUE(result.HasValue()); |
1249 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1522 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1250 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 1523 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
1251 CheckNonResolutionDefaults(result); | 1524 CheckNonResolutionDefaults(result); |
| 1525 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1252 | 1526 |
1253 blink::WebMediaTrackConstraintSet& advanced3 = | 1527 blink::WebMediaTrackConstraintSet& advanced3 = |
1254 constraint_factory_.AddAdvanced(); | 1528 constraint_factory_.AddAdvanced(); |
1255 advanced3.width.setExact(1920); | 1529 advanced3.width.setExact(1920); |
1256 advanced3.height.setExact(1080); | 1530 advanced3.height.setExact(1080); |
1257 result = SelectSettings(); | 1531 result = SelectSettings(); |
1258 EXPECT_TRUE(result.HasValue()); | 1532 EXPECT_TRUE(result.HasValue()); |
1259 EXPECT_EQ(1920, result.Width()); | 1533 EXPECT_EQ(1920, result.Width()); |
1260 EXPECT_EQ(1080, result.Height()); | 1534 EXPECT_EQ(1080, result.Height()); |
1261 CheckNonResolutionDefaults(result); | 1535 CheckNonResolutionDefaults(result); |
| 1536 EXPECT_EQ(1920.0 / 1080.0, |
| 1537 result.track_adapter_settings().min_aspect_ratio); |
| 1538 EXPECT_EQ(1920.0 / 1080.0, |
| 1539 result.track_adapter_settings().max_aspect_ratio); |
| 1540 CheckTrackAdapterSettingsEqualsFormat(result); |
1262 | 1541 |
1263 blink::WebMediaTrackConstraintSet& advanced4 = | 1542 blink::WebMediaTrackConstraintSet& advanced4 = |
1264 constraint_factory_.AddAdvanced(); | 1543 constraint_factory_.AddAdvanced(); |
1265 advanced4.width.setExact(640); | 1544 advanced4.width.setExact(640); |
1266 advanced4.height.setExact(480); | 1545 advanced4.height.setExact(480); |
1267 result = SelectSettings(); | 1546 result = SelectSettings(); |
1268 // The fourth constraint set contradicts the third set. The fourth set | 1547 // The fourth constraint set contradicts the third set. The fourth set |
1269 // should be ignored. | 1548 // should be ignored. |
1270 EXPECT_TRUE(result.HasValue()); | 1549 EXPECT_TRUE(result.HasValue()); |
1271 EXPECT_EQ(1920, result.Width()); | 1550 EXPECT_EQ(1920, result.Width()); |
1272 EXPECT_EQ(1080, result.Height()); | 1551 EXPECT_EQ(1080, result.Height()); |
1273 CheckNonResolutionDefaults(result); | 1552 CheckNonResolutionDefaults(result); |
| 1553 EXPECT_EQ(1920.0 / 1080.0, |
| 1554 result.track_adapter_settings().min_aspect_ratio); |
| 1555 EXPECT_EQ(1920.0 / 1080.0, |
| 1556 result.track_adapter_settings().max_aspect_ratio); |
| 1557 CheckTrackAdapterSettingsEqualsFormat(result); |
1274 | 1558 |
1275 constraint_factory_.basic().width.setIdeal(800); | 1559 constraint_factory_.basic().width.setIdeal(800); |
1276 constraint_factory_.basic().height.setIdeal(600); | 1560 constraint_factory_.basic().height.setIdeal(600); |
1277 result = SelectSettings(); | 1561 result = SelectSettings(); |
1278 EXPECT_TRUE(result.HasValue()); | 1562 EXPECT_TRUE(result.HasValue()); |
1279 // The exact constraints has priority over ideal. | 1563 // The exact constraints has priority over ideal. |
1280 EXPECT_EQ(1920, result.Width()); | 1564 EXPECT_EQ(1920, result.Width()); |
1281 EXPECT_EQ(1080, result.Height()); | 1565 EXPECT_EQ(1080, result.Height()); |
1282 CheckNonResolutionDefaults(result); | 1566 CheckNonResolutionDefaults(result); |
| 1567 EXPECT_EQ(1920.0 / 1080.0, |
| 1568 result.track_adapter_settings().min_aspect_ratio); |
| 1569 EXPECT_EQ(1920.0 / 1080.0, |
| 1570 result.track_adapter_settings().max_aspect_ratio); |
| 1571 CheckTrackAdapterSettingsEqualsFormat(result); |
1283 } | 1572 } |
1284 } | 1573 } |
1285 | 1574 |
1286 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1575 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1287 AdvancedResolutionAndFrameRate) { | 1576 AdvancedResolutionAndFrameRate) { |
1288 constraint_factory_.Reset(); | 1577 constraint_factory_.Reset(); |
1289 blink::WebMediaTrackConstraintSet& advanced1 = | 1578 blink::WebMediaTrackConstraintSet& advanced1 = |
1290 constraint_factory_.AddAdvanced(); | 1579 constraint_factory_.AddAdvanced(); |
1291 advanced1.width.setExact(1920); | 1580 advanced1.width.setExact(1920); |
1292 advanced1.height.setExact(1080); | 1581 advanced1.height.setExact(1080); |
1293 blink::WebMediaTrackConstraintSet& advanced2 = | 1582 blink::WebMediaTrackConstraintSet& advanced2 = |
1294 constraint_factory_.AddAdvanced(); | 1583 constraint_factory_.AddAdvanced(); |
1295 advanced2.frameRate.setExact(60.0); | 1584 advanced2.frameRate.setExact(60.0); |
1296 auto result = SelectSettings(); | 1585 auto result = SelectSettings(); |
1297 EXPECT_TRUE(result.HasValue()); | 1586 EXPECT_TRUE(result.HasValue()); |
1298 EXPECT_EQ(1920, result.Width()); | 1587 EXPECT_EQ(1920, result.Width()); |
1299 EXPECT_EQ(1080, result.Height()); | 1588 EXPECT_EQ(1080, result.Height()); |
1300 EXPECT_EQ(60.0, result.FrameRate()); | 1589 EXPECT_EQ(60.0, result.FrameRate()); |
| 1590 EXPECT_EQ(1920.0 / 1080.0, result.track_adapter_settings().min_aspect_ratio); |
| 1591 EXPECT_EQ(1920.0 / 1080.0, result.track_adapter_settings().max_aspect_ratio); |
| 1592 CheckTrackAdapterSettingsEqualsFormat(result); |
1301 } | 1593 } |
1302 | 1594 |
1303 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedNoiseReduction) { | 1595 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedNoiseReduction) { |
1304 constraint_factory_.Reset(); | 1596 constraint_factory_.Reset(); |
1305 blink::WebMediaTrackConstraintSet& advanced1 = | 1597 blink::WebMediaTrackConstraintSet& advanced1 = |
1306 constraint_factory_.AddAdvanced(); | 1598 constraint_factory_.AddAdvanced(); |
1307 advanced1.width.setMin(640); | 1599 advanced1.width.setMin(640); |
1308 advanced1.height.setMin(480); | 1600 advanced1.height.setMin(480); |
1309 blink::WebMediaTrackConstraintSet& advanced2 = | 1601 blink::WebMediaTrackConstraintSet& advanced2 = |
1310 constraint_factory_.AddAdvanced(); | 1602 constraint_factory_.AddAdvanced(); |
1311 advanced2.width.setMin(1920); | 1603 advanced2.width.setMin(1920); |
1312 advanced2.height.setMin(1080); | 1604 advanced2.height.setMin(1080); |
1313 advanced2.googNoiseReduction.setExact(false); | 1605 advanced2.googNoiseReduction.setExact(false); |
1314 auto result = SelectSettings(); | 1606 auto result = SelectSettings(); |
1315 EXPECT_TRUE(result.HasValue()); | 1607 EXPECT_TRUE(result.HasValue()); |
1316 EXPECT_EQ(1920, result.Width()); | 1608 EXPECT_EQ(1920, result.Width()); |
1317 // Preserves default aspect ratio. | 1609 // Preserves default aspect ratio. |
1318 EXPECT_EQ(static_cast<int>(std::round( | 1610 EXPECT_EQ(static_cast<int>( |
1319 result.Width() / MediaStreamVideoSource::kDefaultAspectRatio)), | 1611 std::round(result.Width() / kDefaultScreenCastAspectRatio)), |
1320 result.Height()); | 1612 result.Height()); |
1321 EXPECT_TRUE(result.noise_reduction() && !*result.noise_reduction()); | 1613 EXPECT_TRUE(result.noise_reduction() && !*result.noise_reduction()); |
| 1614 EXPECT_EQ(1920.0 / static_cast<double>(kMaxScreenCastDimension), |
| 1615 result.track_adapter_settings().min_aspect_ratio); |
| 1616 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / 1080.0, |
| 1617 result.track_adapter_settings().max_aspect_ratio); |
| 1618 CheckTrackAdapterSettingsEqualsFormat(result); |
1322 } | 1619 } |
1323 | 1620 |
1324 // The "AdvancedContradictory" tests check that advanced constraint sets that | 1621 // The "AdvancedContradictory" tests check that advanced constraint sets that |
1325 // contradict previous constraint sets are ignored. | 1622 // contradict previous constraint sets are ignored. |
1326 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1623 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1327 AdvancedContradictoryNoiseReduction) { | 1624 AdvancedContradictoryNoiseReduction) { |
1328 constraint_factory_.Reset(); | 1625 constraint_factory_.Reset(); |
1329 blink::WebMediaTrackConstraintSet& advanced1 = | 1626 blink::WebMediaTrackConstraintSet& advanced1 = |
1330 constraint_factory_.AddAdvanced(); | 1627 constraint_factory_.AddAdvanced(); |
1331 advanced1.width.setExact(640); | 1628 advanced1.width.setExact(640); |
1332 advanced1.height.setExact(480); | 1629 advanced1.height.setExact(480); |
1333 advanced1.googNoiseReduction.setExact(true); | 1630 advanced1.googNoiseReduction.setExact(true); |
1334 blink::WebMediaTrackConstraintSet& advanced2 = | 1631 blink::WebMediaTrackConstraintSet& advanced2 = |
1335 constraint_factory_.AddAdvanced(); | 1632 constraint_factory_.AddAdvanced(); |
1336 advanced2.width.setExact(1920); | 1633 advanced2.width.setExact(1920); |
1337 advanced2.height.setExact(1080); | 1634 advanced2.height.setExact(1080); |
1338 advanced2.googNoiseReduction.setExact(false); | 1635 advanced2.googNoiseReduction.setExact(false); |
1339 auto result = SelectSettings(); | 1636 auto result = SelectSettings(); |
1340 EXPECT_TRUE(result.HasValue()); | 1637 EXPECT_TRUE(result.HasValue()); |
1341 EXPECT_EQ(640, result.Width()); | 1638 EXPECT_EQ(640, result.Width()); |
1342 EXPECT_EQ(480, result.Height()); | 1639 EXPECT_EQ(480, result.Height()); |
1343 EXPECT_TRUE(result.noise_reduction() && *result.noise_reduction()); | 1640 EXPECT_TRUE(result.noise_reduction() && *result.noise_reduction()); |
| 1641 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio); |
| 1642 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio); |
| 1643 CheckTrackAdapterSettingsEqualsFormat(result); |
1344 } | 1644 } |
1345 | 1645 |
1346 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1646 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1347 AdvancedContradictoryExactResolution) { | 1647 AdvancedContradictoryExactResolution) { |
1348 constraint_factory_.Reset(); | 1648 constraint_factory_.Reset(); |
1349 blink::WebMediaTrackConstraintSet& advanced1 = | 1649 blink::WebMediaTrackConstraintSet& advanced1 = |
1350 constraint_factory_.AddAdvanced(); | 1650 constraint_factory_.AddAdvanced(); |
1351 advanced1.width.setExact(640); | 1651 advanced1.width.setExact(640); |
1352 advanced1.height.setExact(480); | 1652 advanced1.height.setExact(480); |
1353 blink::WebMediaTrackConstraintSet& advanced2 = | 1653 blink::WebMediaTrackConstraintSet& advanced2 = |
1354 constraint_factory_.AddAdvanced(); | 1654 constraint_factory_.AddAdvanced(); |
1355 advanced2.width.setExact(1920); | 1655 advanced2.width.setExact(1920); |
1356 advanced2.height.setExact(1080); | 1656 advanced2.height.setExact(1080); |
1357 auto result = SelectSettings(); | 1657 auto result = SelectSettings(); |
1358 EXPECT_TRUE(result.HasValue()); | 1658 EXPECT_TRUE(result.HasValue()); |
1359 EXPECT_EQ(640, result.Width()); | 1659 EXPECT_EQ(640, result.Width()); |
1360 EXPECT_EQ(480, result.Height()); | 1660 EXPECT_EQ(480, result.Height()); |
1361 // Resolution cannot be adjusted due to exact in the first advanced set. | |
1362 CheckNonResolutionDefaults(result); | 1661 CheckNonResolutionDefaults(result); |
| 1662 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio); |
| 1663 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio); |
| 1664 CheckTrackAdapterSettingsEqualsFormat(result); |
1363 } | 1665 } |
1364 | 1666 |
1365 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1667 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1366 AdvancedContradictoryMaxMinResolutionFrameRate) { | 1668 AdvancedContradictoryMaxMinResolutionFrameRate) { |
1367 constraint_factory_.Reset(); | 1669 constraint_factory_.Reset(); |
1368 blink::WebMediaTrackConstraintSet& advanced1 = | 1670 blink::WebMediaTrackConstraintSet& advanced1 = |
1369 constraint_factory_.AddAdvanced(); | 1671 constraint_factory_.AddAdvanced(); |
1370 advanced1.width.setMax(640); | 1672 advanced1.width.setMax(640); |
1371 advanced1.height.setMax(480); | 1673 advanced1.height.setMax(480); |
1372 blink::WebMediaTrackConstraintSet& advanced2 = | 1674 blink::WebMediaTrackConstraintSet& advanced2 = |
1373 constraint_factory_.AddAdvanced(); | 1675 constraint_factory_.AddAdvanced(); |
1374 advanced2.width.setMin(1920); | 1676 advanced2.width.setMin(1920); |
1375 advanced2.height.setMin(1080); | 1677 advanced2.height.setMin(1080); |
1376 advanced2.frameRate.setExact(60.0); | 1678 advanced2.frameRate.setExact(60.0); |
1377 auto result = SelectSettings(); | 1679 auto result = SelectSettings(); |
1378 EXPECT_TRUE(result.HasValue()); | 1680 EXPECT_TRUE(result.HasValue()); |
1379 EXPECT_EQ(640, result.Width()); | 1681 EXPECT_EQ(640, result.Width()); |
1380 EXPECT_EQ(480, result.Height()); | 1682 EXPECT_EQ(480, result.Height()); |
1381 // Resolution cannot exceed the requested resolution. | 1683 // Resolution cannot exceed the requested resolution. |
1382 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1684 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
| 1685 EXPECT_EQ(kMinScreenCastDimension / 480.0, |
| 1686 result.track_adapter_settings().min_aspect_ratio); |
| 1687 EXPECT_EQ(640.0 / kMinScreenCastDimension, |
| 1688 result.track_adapter_settings().max_aspect_ratio); |
| 1689 CheckTrackAdapterSettingsEqualsFormat(result); |
1383 } | 1690 } |
1384 | 1691 |
1385 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1692 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1386 AdvancedContradictoryMinMaxResolutionFrameRate) { | 1693 AdvancedContradictoryMinMaxResolutionFrameRate) { |
1387 constraint_factory_.Reset(); | 1694 constraint_factory_.Reset(); |
1388 blink::WebMediaTrackConstraintSet& advanced1 = | 1695 blink::WebMediaTrackConstraintSet& advanced1 = |
1389 constraint_factory_.AddAdvanced(); | 1696 constraint_factory_.AddAdvanced(); |
1390 advanced1.width.setMin(800); | 1697 advanced1.width.setMin(800); |
1391 advanced1.height.setMin(600); | 1698 advanced1.height.setMin(600); |
1392 blink::WebMediaTrackConstraintSet& advanced2 = | 1699 blink::WebMediaTrackConstraintSet& advanced2 = |
1393 constraint_factory_.AddAdvanced(); | 1700 constraint_factory_.AddAdvanced(); |
1394 advanced2.width.setMax(640); | 1701 advanced2.width.setMax(640); |
1395 advanced2.height.setMax(480); | 1702 advanced2.height.setMax(480); |
1396 advanced2.frameRate.setExact(60.0); | 1703 advanced2.frameRate.setExact(60.0); |
1397 auto result = SelectSettings(); | 1704 auto result = SelectSettings(); |
1398 EXPECT_TRUE(result.HasValue()); | 1705 EXPECT_TRUE(result.HasValue()); |
1399 EXPECT_EQ(800, result.Width()); | 1706 EXPECT_EQ(800, result.Width()); |
1400 EXPECT_EQ(600, result.Height()); | 1707 EXPECT_EQ(600, result.Height()); |
1401 EXPECT_EQ(MediaStreamVideoSource::kDefaultFrameRate, result.FrameRate()); | 1708 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate()); |
| 1709 EXPECT_EQ(800.0 / kMaxScreenCastDimension, |
| 1710 result.track_adapter_settings().min_aspect_ratio); |
| 1711 EXPECT_EQ(kMaxScreenCastDimension / 600.0, |
| 1712 result.track_adapter_settings().max_aspect_ratio); |
| 1713 CheckTrackAdapterSettingsEqualsFormat(result); |
1402 } | 1714 } |
1403 | 1715 |
1404 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1716 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1405 AdvancedContradictoryExactAspectRatio) { | 1717 AdvancedContradictoryExactAspectRatio) { |
1406 constraint_factory_.Reset(); | 1718 constraint_factory_.Reset(); |
1407 blink::WebMediaTrackConstraintSet& advanced1 = | 1719 blink::WebMediaTrackConstraintSet& advanced1 = |
1408 constraint_factory_.AddAdvanced(); | 1720 constraint_factory_.AddAdvanced(); |
1409 advanced1.aspectRatio.setExact(10.0); | 1721 advanced1.aspectRatio.setExact(10.0); |
1410 blink::WebMediaTrackConstraintSet& advanced2 = | 1722 blink::WebMediaTrackConstraintSet& advanced2 = |
1411 constraint_factory_.AddAdvanced(); | 1723 constraint_factory_.AddAdvanced(); |
1412 advanced2.aspectRatio.setExact(3.0); | 1724 advanced2.aspectRatio.setExact(3.0); |
1413 auto result = SelectSettings(); | 1725 auto result = SelectSettings(); |
1414 EXPECT_TRUE(result.HasValue()); | 1726 EXPECT_TRUE(result.HasValue()); |
1415 EXPECT_EQ(std::round(MediaStreamVideoSource::kDefaultHeight * 10.0), | 1727 EXPECT_EQ(std::round(kDefaultScreenCastHeight * 10.0), result.Width()); |
1416 result.Width()); | 1728 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1417 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | |
1418 CheckNonResolutionDefaults(result); | 1729 CheckNonResolutionDefaults(result); |
| 1730 EXPECT_EQ(10.0, result.track_adapter_settings().min_aspect_ratio); |
| 1731 EXPECT_EQ(10.0, result.track_adapter_settings().max_aspect_ratio); |
| 1732 CheckTrackAdapterSettingsEqualsFormat(result); |
1419 } | 1733 } |
1420 | 1734 |
1421 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1735 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1422 AdvancedContradictoryAspectRatioRange) { | 1736 AdvancedContradictoryAspectRatioRange) { |
1423 constraint_factory_.Reset(); | 1737 constraint_factory_.Reset(); |
1424 blink::WebMediaTrackConstraintSet& advanced1 = | 1738 blink::WebMediaTrackConstraintSet& advanced1 = |
1425 constraint_factory_.AddAdvanced(); | 1739 constraint_factory_.AddAdvanced(); |
1426 advanced1.aspectRatio.setMin(10.0); | 1740 advanced1.aspectRatio.setMin(10.0); |
1427 blink::WebMediaTrackConstraintSet& advanced2 = | 1741 blink::WebMediaTrackConstraintSet& advanced2 = |
1428 constraint_factory_.AddAdvanced(); | 1742 constraint_factory_.AddAdvanced(); |
1429 advanced2.aspectRatio.setMax(3.0); | 1743 advanced2.aspectRatio.setMax(3.0); |
1430 auto result = SelectSettings(); | 1744 auto result = SelectSettings(); |
1431 EXPECT_TRUE(result.HasValue()); | 1745 EXPECT_TRUE(result.HasValue()); |
1432 EXPECT_EQ(std::round(MediaStreamVideoSource::kDefaultHeight * 10.0), | 1746 EXPECT_EQ(std::round(kDefaultScreenCastHeight * 10.0), result.Width()); |
1433 result.Width()); | 1747 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1434 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | |
1435 CheckNonResolutionDefaults(result); | 1748 CheckNonResolutionDefaults(result); |
| 1749 EXPECT_EQ(10.0, result.track_adapter_settings().min_aspect_ratio); |
| 1750 EXPECT_EQ( |
| 1751 kMaxScreenCastDimension / static_cast<double>(kMinScreenCastDimension), |
| 1752 result.track_adapter_settings().max_aspect_ratio); |
| 1753 CheckTrackAdapterSettingsEqualsFormat(result); |
1436 } | 1754 } |
1437 | 1755 |
1438 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1756 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1439 AdvancedContradictoryExactFrameRate) { | 1757 AdvancedContradictoryExactFrameRate) { |
1440 constraint_factory_.Reset(); | 1758 constraint_factory_.Reset(); |
1441 blink::WebMediaTrackConstraintSet& advanced1 = | 1759 blink::WebMediaTrackConstraintSet& advanced1 = |
1442 constraint_factory_.AddAdvanced(); | 1760 constraint_factory_.AddAdvanced(); |
1443 advanced1.frameRate.setExact(40.0); | 1761 advanced1.frameRate.setExact(40.0); |
1444 blink::WebMediaTrackConstraintSet& advanced2 = | 1762 blink::WebMediaTrackConstraintSet& advanced2 = |
1445 constraint_factory_.AddAdvanced(); | 1763 constraint_factory_.AddAdvanced(); |
1446 advanced2.frameRate.setExact(45.0); | 1764 advanced2.frameRate.setExact(45.0); |
1447 auto result = SelectSettings(); | 1765 auto result = SelectSettings(); |
1448 EXPECT_TRUE(result.HasValue()); | 1766 EXPECT_TRUE(result.HasValue()); |
1449 EXPECT_EQ(40.0, result.FrameRate()); | 1767 EXPECT_EQ(40.0, result.FrameRate()); |
1450 CheckNonFrameRateDefaults(result); | 1768 CheckNonFrameRateDefaults(result); |
| 1769 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1451 } | 1770 } |
1452 | 1771 |
1453 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1772 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1454 AdvancedContradictoryFrameRateRange) { | 1773 AdvancedContradictoryFrameRateRange) { |
1455 constraint_factory_.Reset(); | 1774 constraint_factory_.Reset(); |
1456 blink::WebMediaTrackConstraintSet& advanced1 = | 1775 blink::WebMediaTrackConstraintSet& advanced1 = |
1457 constraint_factory_.AddAdvanced(); | 1776 constraint_factory_.AddAdvanced(); |
1458 advanced1.frameRate.setMin(40.0); | 1777 advanced1.frameRate.setMin(40.0); |
1459 blink::WebMediaTrackConstraintSet& advanced2 = | 1778 blink::WebMediaTrackConstraintSet& advanced2 = |
1460 constraint_factory_.AddAdvanced(); | 1779 constraint_factory_.AddAdvanced(); |
1461 advanced2.frameRate.setMax(35.0); | 1780 advanced2.frameRate.setMax(35.0); |
1462 auto result = SelectSettings(); | 1781 auto result = SelectSettings(); |
1463 EXPECT_TRUE(result.HasValue()); | 1782 EXPECT_TRUE(result.HasValue()); |
1464 EXPECT_LE(40.0, result.FrameRate()); | 1783 EXPECT_LE(40.0, result.FrameRate()); |
1465 CheckNonFrameRateDefaults(result); | 1784 CheckNonFrameRateDefaults(result); |
| 1785 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1466 } | 1786 } |
1467 | 1787 |
1468 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1788 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1469 AdvancedContradictoryWidthFrameRate) { | 1789 AdvancedContradictoryWidthFrameRate) { |
1470 constraint_factory_.Reset(); | 1790 constraint_factory_.Reset(); |
1471 blink::WebMediaTrackConstraintSet& advanced1 = | 1791 blink::WebMediaTrackConstraintSet& advanced1 = |
1472 constraint_factory_.AddAdvanced(); | 1792 constraint_factory_.AddAdvanced(); |
1473 advanced1.width.setMax(1920); | 1793 advanced1.width.setMax(1920); |
1474 blink::WebMediaTrackConstraintSet& advanced2 = | 1794 blink::WebMediaTrackConstraintSet& advanced2 = |
1475 constraint_factory_.AddAdvanced(); | 1795 constraint_factory_.AddAdvanced(); |
1476 advanced2.width.setMin(2000); | 1796 advanced2.width.setMin(2000); |
1477 advanced2.frameRate.setExact(10.0); | 1797 advanced2.frameRate.setExact(10.0); |
1478 blink::WebMediaTrackConstraintSet& advanced3 = | 1798 blink::WebMediaTrackConstraintSet& advanced3 = |
1479 constraint_factory_.AddAdvanced(); | 1799 constraint_factory_.AddAdvanced(); |
1480 advanced3.frameRate.setExact(90.0); | 1800 advanced3.frameRate.setExact(90.0); |
1481 auto result = SelectSettings(); | 1801 auto result = SelectSettings(); |
1482 EXPECT_TRUE(result.HasValue()); | 1802 EXPECT_TRUE(result.HasValue()); |
1483 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 1803 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
1484 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1804 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1485 EXPECT_EQ(90.0, result.FrameRate()); | 1805 EXPECT_EQ(90.0, result.FrameRate()); |
| 1806 EXPECT_EQ( |
| 1807 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension, |
| 1808 result.track_adapter_settings().min_aspect_ratio); |
| 1809 EXPECT_EQ(1920.0 / kMinScreenCastDimension, |
| 1810 result.track_adapter_settings().max_aspect_ratio); |
| 1811 CheckTrackAdapterSettingsEqualsFormat(result); |
1486 } | 1812 } |
1487 | 1813 |
1488 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1814 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1489 AdvancedContradictoryHeightFrameRate) { | 1815 AdvancedContradictoryHeightFrameRate) { |
1490 constraint_factory_.Reset(); | 1816 constraint_factory_.Reset(); |
1491 blink::WebMediaTrackConstraintSet& advanced1 = | 1817 blink::WebMediaTrackConstraintSet& advanced1 = |
1492 constraint_factory_.AddAdvanced(); | 1818 constraint_factory_.AddAdvanced(); |
1493 advanced1.height.setMax(1080); | 1819 advanced1.height.setMax(1080); |
1494 blink::WebMediaTrackConstraintSet& advanced2 = | 1820 blink::WebMediaTrackConstraintSet& advanced2 = |
1495 constraint_factory_.AddAdvanced(); | 1821 constraint_factory_.AddAdvanced(); |
1496 advanced2.height.setMin(1500); | 1822 advanced2.height.setMin(1500); |
1497 advanced2.frameRate.setExact(10.0); | 1823 advanced2.frameRate.setExact(10.0); |
1498 blink::WebMediaTrackConstraintSet& advanced3 = | 1824 blink::WebMediaTrackConstraintSet& advanced3 = |
1499 constraint_factory_.AddAdvanced(); | 1825 constraint_factory_.AddAdvanced(); |
1500 advanced3.frameRate.setExact(60.0); | 1826 advanced3.frameRate.setExact(60.0); |
1501 auto result = SelectSettings(); | 1827 auto result = SelectSettings(); |
1502 EXPECT_TRUE(result.HasValue()); | 1828 EXPECT_TRUE(result.HasValue()); |
1503 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 1829 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
1504 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1830 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1505 EXPECT_EQ(60.0, result.FrameRate()); | 1831 EXPECT_EQ(60.0, result.FrameRate()); |
| 1832 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / 1080.0, |
| 1833 result.track_adapter_settings().min_aspect_ratio); |
| 1834 EXPECT_EQ( |
| 1835 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension, |
| 1836 result.track_adapter_settings().max_aspect_ratio); |
| 1837 CheckTrackAdapterSettingsEqualsFormat(result); |
1506 } | 1838 } |
1507 | 1839 |
1508 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedDeviceID) { | 1840 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedDeviceID) { |
1509 const std::string kDeviceID1 = "fake_device_1"; | 1841 const std::string kDeviceID1 = "fake_device_1"; |
1510 const std::string kDeviceID2 = "fake_device_2"; | 1842 const std::string kDeviceID2 = "fake_device_2"; |
1511 const std::string kDeviceID3 = "fake_device_3"; | 1843 const std::string kDeviceID3 = "fake_device_3"; |
1512 const std::string kDeviceID4 = "fake_device_4"; | 1844 const std::string kDeviceID4 = "fake_device_4"; |
1513 constraint_factory_.Reset(); | 1845 constraint_factory_.Reset(); |
1514 blink::WebMediaTrackConstraintSet& advanced1 = | 1846 blink::WebMediaTrackConstraintSet& advanced1 = |
1515 constraint_factory_.AddAdvanced(); | 1847 constraint_factory_.AddAdvanced(); |
1516 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), | 1848 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), |
1517 blink::WebString::fromASCII(kDeviceID2)}; | 1849 blink::WebString::fromASCII(kDeviceID2)}; |
1518 advanced1.deviceId.setExact( | 1850 advanced1.deviceId.setExact( |
1519 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); | 1851 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); |
1520 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID2), | 1852 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID2), |
1521 blink::WebString::fromASCII(kDeviceID3)}; | 1853 blink::WebString::fromASCII(kDeviceID3)}; |
1522 blink::WebMediaTrackConstraintSet& advanced2 = | 1854 blink::WebMediaTrackConstraintSet& advanced2 = |
1523 constraint_factory_.AddAdvanced(); | 1855 constraint_factory_.AddAdvanced(); |
1524 advanced2.deviceId.setExact( | 1856 advanced2.deviceId.setExact( |
1525 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); | 1857 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); |
1526 auto result = SelectSettings(); | 1858 auto result = SelectSettings(); |
1527 EXPECT_TRUE(result.HasValue()); | 1859 EXPECT_TRUE(result.HasValue()); |
1528 // kDeviceID2 must be selected because it is the only one that satisfies both | 1860 // kDeviceID2 must be selected because it is the only one that satisfies both |
1529 // advanced sets. | 1861 // advanced sets. |
1530 EXPECT_EQ(kDeviceID2, result.device_id()); | 1862 EXPECT_EQ(kDeviceID2, result.device_id()); |
| 1863 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1531 } | 1864 } |
1532 | 1865 |
1533 TEST_F(MediaStreamConstraintsUtilVideoContentTest, | 1866 TEST_F(MediaStreamConstraintsUtilVideoContentTest, |
1534 AdvancedContradictoryDeviceID) { | 1867 AdvancedContradictoryDeviceID) { |
1535 const std::string kDeviceID1 = "fake_device_1"; | 1868 const std::string kDeviceID1 = "fake_device_1"; |
1536 const std::string kDeviceID2 = "fake_device_2"; | 1869 const std::string kDeviceID2 = "fake_device_2"; |
1537 const std::string kDeviceID3 = "fake_device_3"; | 1870 const std::string kDeviceID3 = "fake_device_3"; |
1538 const std::string kDeviceID4 = "fake_device_4"; | 1871 const std::string kDeviceID4 = "fake_device_4"; |
1539 constraint_factory_.Reset(); | 1872 constraint_factory_.Reset(); |
1540 blink::WebMediaTrackConstraintSet& advanced1 = | 1873 blink::WebMediaTrackConstraintSet& advanced1 = |
1541 constraint_factory_.AddAdvanced(); | 1874 constraint_factory_.AddAdvanced(); |
1542 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), | 1875 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), |
1543 blink::WebString::fromASCII(kDeviceID2)}; | 1876 blink::WebString::fromASCII(kDeviceID2)}; |
1544 advanced1.deviceId.setExact( | 1877 advanced1.deviceId.setExact( |
1545 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); | 1878 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); |
1546 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID3), | 1879 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID3), |
1547 blink::WebString::fromASCII(kDeviceID4)}; | 1880 blink::WebString::fromASCII(kDeviceID4)}; |
1548 blink::WebMediaTrackConstraintSet& advanced2 = | 1881 blink::WebMediaTrackConstraintSet& advanced2 = |
1549 constraint_factory_.AddAdvanced(); | 1882 constraint_factory_.AddAdvanced(); |
1550 advanced2.deviceId.setExact( | 1883 advanced2.deviceId.setExact( |
1551 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); | 1884 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); |
1552 auto result = SelectSettings(); | 1885 auto result = SelectSettings(); |
1553 EXPECT_TRUE(result.HasValue()); | 1886 EXPECT_TRUE(result.HasValue()); |
1554 // The second advanced set must be ignored because it contradicts the first | 1887 // The second advanced set must be ignored because it contradicts the first |
1555 // set. | 1888 // set. |
1556 EXPECT_EQ(std::string(kDeviceID1), result.device_id()); | 1889 EXPECT_EQ(std::string(kDeviceID1), result.device_id()); |
| 1890 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1557 } | 1891 } |
1558 | 1892 |
1559 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedIdealDeviceID) { | 1893 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedIdealDeviceID) { |
1560 const std::string kDeviceID1 = "fake_device_1"; | 1894 const std::string kDeviceID1 = "fake_device_1"; |
1561 const std::string kDeviceID2 = "fake_device_2"; | 1895 const std::string kDeviceID2 = "fake_device_2"; |
1562 const std::string kDeviceID3 = "fake_device_3"; | 1896 const std::string kDeviceID3 = "fake_device_3"; |
1563 constraint_factory_.Reset(); | 1897 constraint_factory_.Reset(); |
1564 blink::WebMediaTrackConstraintSet& advanced = | 1898 blink::WebMediaTrackConstraintSet& advanced = |
1565 constraint_factory_.AddAdvanced(); | 1899 constraint_factory_.AddAdvanced(); |
1566 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), | 1900 blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1), |
1567 blink::WebString::fromASCII(kDeviceID2)}; | 1901 blink::WebString::fromASCII(kDeviceID2)}; |
1568 advanced.deviceId.setExact( | 1902 advanced.deviceId.setExact( |
1569 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); | 1903 blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1))); |
1570 | 1904 |
1571 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID2), | 1905 blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID2), |
1572 blink::WebString::fromASCII(kDeviceID3)}; | 1906 blink::WebString::fromASCII(kDeviceID3)}; |
1573 constraint_factory_.basic().deviceId.setIdeal( | 1907 constraint_factory_.basic().deviceId.setIdeal( |
1574 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); | 1908 blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2))); |
1575 auto result = SelectSettings(); | 1909 auto result = SelectSettings(); |
1576 EXPECT_TRUE(result.HasValue()); | 1910 EXPECT_TRUE(result.HasValue()); |
1577 // Should select kDeviceID2, which appears in ideal and satisfies the advanced | 1911 // Should select kDeviceID2, which appears in ideal and satisfies the advanced |
1578 // set. | 1912 // set. |
1579 EXPECT_EQ(std::string(kDeviceID2), result.device_id()); | 1913 EXPECT_EQ(std::string(kDeviceID2), result.device_id()); |
| 1914 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1580 } | 1915 } |
1581 | 1916 |
1582 TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) { | 1917 TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) { |
1583 { | 1918 { |
1584 constraint_factory_.Reset(); | 1919 constraint_factory_.Reset(); |
1585 auto result = SelectSettings(); | 1920 auto result = SelectSettings(); |
1586 EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth, result.Width()); | 1921 EXPECT_EQ(kDefaultScreenCastWidth, result.Width()); |
1587 EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight, result.Height()); | 1922 EXPECT_EQ(kDefaultScreenCastHeight, result.Height()); |
1588 // Resolution can be adjusted. | 1923 // Resolution can be adjusted. |
1589 EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT, | 1924 EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT, |
1590 result.ResolutionChangePolicy()); | 1925 result.ResolutionChangePolicy()); |
| 1926 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1591 } | 1927 } |
1592 { | 1928 { |
1593 constraint_factory_.Reset(); | 1929 constraint_factory_.Reset(); |
1594 constraint_factory_.basic().width.setIdeal(630); | 1930 constraint_factory_.basic().width.setIdeal(630); |
1595 constraint_factory_.basic().height.setIdeal(470); | 1931 constraint_factory_.basic().height.setIdeal(470); |
1596 auto result = SelectSettings(); | 1932 auto result = SelectSettings(); |
1597 EXPECT_EQ(630, result.Width()); | 1933 EXPECT_EQ(630, result.Width()); |
1598 EXPECT_EQ(470, result.Height()); | 1934 EXPECT_EQ(470, result.Height()); |
1599 // Resolution can be adjusted because ideal was used to select the | 1935 // Resolution can be adjusted because ideal was used to select the |
1600 // resolution. | 1936 // resolution. |
1601 EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT, | 1937 EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT, |
1602 result.ResolutionChangePolicy()); | 1938 result.ResolutionChangePolicy()); |
| 1939 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result); |
1603 } | 1940 } |
1604 { | 1941 { |
1605 constraint_factory_.Reset(); | 1942 constraint_factory_.Reset(); |
1606 constraint_factory_.basic().width.setExact(640); | 1943 constraint_factory_.basic().width.setExact(640); |
1607 constraint_factory_.basic().height.setExact(480); | 1944 constraint_factory_.basic().height.setExact(480); |
1608 auto result = SelectSettings(); | 1945 auto result = SelectSettings(); |
1609 EXPECT_EQ(640, result.Width()); | 1946 EXPECT_EQ(640, result.Width()); |
1610 EXPECT_EQ(480, result.Height()); | 1947 EXPECT_EQ(480, result.Height()); |
1611 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, | 1948 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, |
1612 result.ResolutionChangePolicy()); | 1949 result.ResolutionChangePolicy()); |
| 1950 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio); |
| 1951 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio); |
| 1952 CheckTrackAdapterSettingsEqualsFormat(result); |
1613 } | 1953 } |
1614 { | 1954 { |
1615 constraint_factory_.Reset(); | 1955 constraint_factory_.Reset(); |
1616 constraint_factory_.basic().width.setExact(1000); | 1956 constraint_factory_.basic().width.setExact(1000); |
1617 constraint_factory_.basic().height.setExact(500); | 1957 constraint_factory_.basic().height.setExact(500); |
1618 auto result = SelectSettings(); | 1958 auto result = SelectSettings(); |
1619 EXPECT_EQ(1000, result.Width()); | 1959 EXPECT_EQ(1000, result.Width()); |
1620 EXPECT_EQ(500, result.Height()); | 1960 EXPECT_EQ(500, result.Height()); |
1621 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, | 1961 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, |
1622 result.ResolutionChangePolicy()); | 1962 result.ResolutionChangePolicy()); |
| 1963 EXPECT_EQ(1000.0 / 500.0, result.track_adapter_settings().min_aspect_ratio); |
| 1964 EXPECT_EQ(1000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio); |
| 1965 CheckTrackAdapterSettingsEqualsFormat(result); |
1623 } | 1966 } |
1624 { | 1967 { |
1625 constraint_factory_.Reset(); | 1968 constraint_factory_.Reset(); |
1626 constraint_factory_.basic().width.setExact(630); | 1969 constraint_factory_.basic().width.setExact(630); |
1627 constraint_factory_.basic().height.setExact(470); | 1970 constraint_factory_.basic().height.setExact(470); |
1628 auto result = SelectSettings(); | 1971 auto result = SelectSettings(); |
1629 EXPECT_EQ(630, result.Width()); | 1972 EXPECT_EQ(630, result.Width()); |
1630 EXPECT_EQ(470, result.Height()); | 1973 EXPECT_EQ(470, result.Height()); |
1631 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, | 1974 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, |
1632 result.ResolutionChangePolicy()); | 1975 result.ResolutionChangePolicy()); |
| 1976 EXPECT_EQ(630.0 / 470.0, result.track_adapter_settings().min_aspect_ratio); |
| 1977 EXPECT_EQ(630.0 / 470.0, result.track_adapter_settings().max_aspect_ratio); |
| 1978 CheckTrackAdapterSettingsEqualsFormat(result); |
1633 } | 1979 } |
1634 { | 1980 { |
1635 constraint_factory_.Reset(); | 1981 constraint_factory_.Reset(); |
1636 constraint_factory_.basic().width.setIdeal(630); | 1982 constraint_factory_.basic().width.setIdeal(630); |
1637 constraint_factory_.basic().width.setMin(629); | 1983 constraint_factory_.basic().width.setMin(629); |
1638 constraint_factory_.basic().width.setMax(631); | 1984 constraint_factory_.basic().width.setMax(631); |
1639 constraint_factory_.basic().height.setIdeal(470); | 1985 constraint_factory_.basic().height.setIdeal(470); |
1640 constraint_factory_.basic().height.setMin(469); | 1986 constraint_factory_.basic().height.setMin(469); |
1641 auto result = SelectSettings(); | 1987 auto result = SelectSettings(); |
1642 EXPECT_EQ(630, result.Width()); | 1988 EXPECT_EQ(630, result.Width()); |
1643 EXPECT_EQ(470, result.Height()); | 1989 EXPECT_EQ(470, result.Height()); |
1644 // Min/Max ranges prevent the resolution from being adjusted. | 1990 // Min/Max ranges prevent the resolution from being adjusted. |
1645 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, | 1991 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, |
1646 result.ResolutionChangePolicy()); | 1992 result.ResolutionChangePolicy()); |
| 1993 EXPECT_EQ(629.0 / kMaxScreenCastDimension, |
| 1994 result.track_adapter_settings().min_aspect_ratio); |
| 1995 EXPECT_EQ(631.0 / 469.0, result.track_adapter_settings().max_aspect_ratio); |
| 1996 CheckTrackAdapterSettingsEqualsFormat(result); |
1647 } | 1997 } |
1648 { | 1998 { |
1649 constraint_factory_.Reset(); | 1999 constraint_factory_.Reset(); |
1650 constraint_factory_.basic().aspectRatio.setExact(1.32); | 2000 constraint_factory_.basic().aspectRatio.setExact(1.32); |
1651 constraint_factory_.basic().height.setIdeal(480); | 2001 constraint_factory_.basic().height.setIdeal(480); |
1652 auto result = SelectSettings(); | 2002 auto result = SelectSettings(); |
1653 EXPECT_EQ(std::round(480 * 1.32), result.Width()); | 2003 EXPECT_EQ(std::round(480 * 1.32), result.Width()); |
1654 EXPECT_EQ(480, result.Height()); | 2004 EXPECT_EQ(480, result.Height()); |
1655 // Exact aspect ratio prevents the resolution from being adjusted. | 2005 // Exact aspect ratio prevents the resolution from being adjusted. |
1656 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, | 2006 EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION, |
1657 result.ResolutionChangePolicy()); | 2007 result.ResolutionChangePolicy()); |
| 2008 EXPECT_EQ(1.32, result.track_adapter_settings().min_aspect_ratio); |
| 2009 EXPECT_EQ(1.32, result.track_adapter_settings().max_aspect_ratio); |
| 2010 CheckTrackAdapterSettingsEqualsFormat(result); |
1658 } | 2011 } |
1659 } | 2012 } |
1660 | 2013 |
1661 } // namespace content | 2014 } // namespace content |
OLD | NEW |