OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 <string> | 5 #include <string> |
6 #include <vector> | 6 #include <vector> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
11 #include "base/strings/string_number_conversions.h" | 11 #include "base/strings/string_number_conversions.h" |
12 #include "base/strings/utf_string_conversions.h" | 12 #include "base/strings/utf_string_conversions.h" |
13 #include "content/child/child_process.h" | 13 #include "content/child/child_process.h" |
14 #include "content/renderer/media/media_stream_video_source.h" | 14 #include "content/renderer/media/media_stream_video_source.h" |
15 #include "content/renderer/media/media_stream_video_track.h" | 15 #include "content/renderer/media/media_stream_video_track.h" |
16 #include "content/renderer/media/mock_media_constraint_factory.h" | 16 #include "content/renderer/media/mock_constraint_factory.h" |
17 #include "content/renderer/media/mock_media_stream_video_sink.h" | 17 #include "content/renderer/media/mock_media_stream_video_sink.h" |
18 #include "content/renderer/media/mock_media_stream_video_source.h" | 18 #include "content/renderer/media/mock_media_stream_video_source.h" |
| 19 #include "media/base/limits.h" |
19 #include "media/base/video_frame.h" | 20 #include "media/base/video_frame.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
21 #include "third_party/WebKit/public/web/WebHeap.h" | 22 #include "third_party/WebKit/public/web/WebHeap.h" |
22 | 23 |
23 using ::testing::_; | 24 using ::testing::_; |
24 using ::testing::DoAll; | 25 using ::testing::DoAll; |
25 using ::testing::SaveArg; | 26 using ::testing::SaveArg; |
26 | 27 |
27 namespace content { | 28 namespace content { |
28 | 29 |
(...skipping 260 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
289 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); | 290 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); |
290 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); | 291 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); |
291 mock_source()->CompleteGetSupportedFormats(); | 292 mock_source()->CompleteGetSupportedFormats(); |
292 mock_source()->StartMockedSource(); | 293 mock_source()->StartMockedSource(); |
293 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); | 294 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
294 } | 295 } |
295 | 296 |
296 // Test that the capture output is CIF if we set max constraints to CIF. | 297 // Test that the capture output is CIF if we set max constraints to CIF. |
297 // and the capture device support CIF. | 298 // and the capture device support CIF. |
298 TEST_F(MediaStreamVideoSourceTest, MandatoryConstraintCif5Fps) { | 299 TEST_F(MediaStreamVideoSourceTest, MandatoryConstraintCif5Fps) { |
299 MockMediaConstraintFactory factory; | 300 MockConstraintFactory factory; |
300 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 352); | 301 factory.basic().width.setMax(352); |
301 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 288); | 302 factory.basic().height.setMax(288); |
302 factory.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 5); | 303 factory.basic().frameRate.setMax(5.0); |
303 | 304 |
304 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 352, 288, 5); | 305 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 352, 288, 5); |
305 } | 306 } |
306 | 307 |
307 // Test that the capture output is 720P if the camera support it and the | 308 // Test that the capture output is 720P if the camera support it and the |
308 // optional constraint is set to 720P. | 309 // optional constraint is set to 720P. |
309 TEST_F(MediaStreamVideoSourceTest, MandatoryMinVgaOptional720P) { | 310 TEST_F(MediaStreamVideoSourceTest, MandatoryMinVgaOptional720P) { |
310 MockMediaConstraintFactory factory; | 311 MockConstraintFactory factory; |
311 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640); | 312 factory.basic().width.setMin(640); |
312 factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480); | 313 factory.basic().height.setMin(480); |
313 factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 314 factory.AddAdvanced().width.setMin(1280); |
314 factory.AddOptional(MediaStreamVideoSource::kMinAspectRatio, 1280.0 / 720); | 315 factory.AddAdvanced().aspectRatio.setMin(1280.0 / 720); |
315 | 316 |
316 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); | 317 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); |
317 } | 318 } |
318 | 319 |
319 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint | 320 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint |
320 // require it even if an optional constraint request a higher resolution | 321 // require it even if an optional constraint request a higher resolution |
321 // that don't have this aspect ratio. | 322 // that don't have this aspect ratio. |
322 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3) { | 323 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3) { |
323 MockMediaConstraintFactory factory; | 324 MockConstraintFactory factory; |
324 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640); | 325 factory.basic().width.setMin(640); |
325 factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480); | 326 factory.basic().height.setMin(480); |
326 factory.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 640.0 / 480); | 327 factory.basic().aspectRatio.setMax(640.0 / 480); |
327 factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 328 factory.AddAdvanced().width.setMin(1280); |
328 | 329 |
329 TestSourceCropFrame(1280, 720, | 330 TestSourceCropFrame(1280, 720, |
330 factory.CreateWebMediaConstraints(), 960, 720); | 331 factory.CreateWebMediaConstraints(), 960, 720); |
331 } | 332 } |
332 | 333 |
333 // Test that AddTrack succeeds if the mandatory min aspect ratio it set to 2. | 334 // Test that AddTrack succeeds if the mandatory min aspect ratio it set to 2. |
334 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2) { | 335 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2) { |
335 MockMediaConstraintFactory factory; | 336 MockConstraintFactory factory; |
336 factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2); | 337 factory.basic().aspectRatio.setMin(2.0); |
337 | 338 |
338 TestSourceCropFrame(MediaStreamVideoSource::kDefaultWidth, | 339 TestSourceCropFrame(MediaStreamVideoSource::kDefaultWidth, |
339 MediaStreamVideoSource::kDefaultHeight, | 340 MediaStreamVideoSource::kDefaultHeight, |
340 factory.CreateWebMediaConstraints(), 640, 320); | 341 factory.CreateWebMediaConstraints(), 640, 320); |
341 } | 342 } |
342 | 343 |
343 TEST_F(MediaStreamVideoSourceTest, MinAspectRatioLargerThanMaxAspectRatio) { | 344 TEST_F(MediaStreamVideoSourceTest, MinAspectRatioLargerThanMaxAspectRatio) { |
344 MockMediaConstraintFactory factory; | 345 MockConstraintFactory factory; |
345 factory.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 2); | 346 factory.basic().aspectRatio.setMin(2.0); |
346 factory.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 1); | 347 factory.basic().aspectRatio.setMax(1.0); |
347 blink::WebMediaStreamTrack track = CreateTrack( | 348 blink::WebMediaStreamTrack track = CreateTrack( |
348 "123", factory.CreateWebMediaConstraints()); | 349 "123", factory.CreateWebMediaConstraints()); |
349 mock_source()->CompleteGetSupportedFormats(); | 350 mock_source()->CompleteGetSupportedFormats(); |
350 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | |
351 } | |
352 | |
353 TEST_F(MediaStreamVideoSourceTest, MaxAspectRatioZero) { | |
354 MockMediaConstraintFactory factory; | |
355 factory.AddOptional(MediaStreamVideoSource::kMaxAspectRatio, 0); | |
356 blink::WebMediaStreamTrack track = CreateTrack( | |
357 "123", factory.CreateWebMediaConstraints()); | |
358 mock_source()->CompleteGetSupportedFormats(); | |
359 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 351 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
360 } | 352 } |
361 | 353 |
362 TEST_F(MediaStreamVideoSourceTest, MinWidthLargerThanMaxWidth) { | 354 TEST_F(MediaStreamVideoSourceTest, MinWidthLargerThanMaxWidth) { |
363 MockMediaConstraintFactory factory; | 355 MockConstraintFactory factory; |
364 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 640); | 356 factory.basic().width.setMin(640); |
365 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 320); | 357 factory.basic().width.setMax(320); |
366 blink::WebMediaStreamTrack track = CreateTrack( | 358 blink::WebMediaStreamTrack track = CreateTrack( |
367 "123", factory.CreateWebMediaConstraints()); | 359 "123", factory.CreateWebMediaConstraints()); |
368 mock_source()->CompleteGetSupportedFormats(); | 360 mock_source()->CompleteGetSupportedFormats(); |
369 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 361 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
370 } | 362 } |
371 | 363 |
372 TEST_F(MediaStreamVideoSourceTest, MinHeightLargerThanMaxHeight) { | 364 TEST_F(MediaStreamVideoSourceTest, MinHeightLargerThanMaxHeight) { |
373 MockMediaConstraintFactory factory; | 365 MockConstraintFactory factory; |
374 factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 480); | 366 factory.basic().height.setMin(480); |
375 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360); | 367 factory.basic().height.setMax(360); |
| 368 |
376 blink::WebMediaStreamTrack track = CreateTrack( | 369 blink::WebMediaStreamTrack track = CreateTrack( |
377 "123", factory.CreateWebMediaConstraints()); | 370 "123", factory.CreateWebMediaConstraints()); |
378 mock_source()->CompleteGetSupportedFormats(); | 371 mock_source()->CompleteGetSupportedFormats(); |
379 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 372 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
380 } | 373 } |
381 | 374 |
382 TEST_F(MediaStreamVideoSourceTest, MinFrameRateLargerThanMaxFrameRate) { | 375 TEST_F(MediaStreamVideoSourceTest, MinFrameRateLargerThanMaxFrameRate) { |
383 MockMediaConstraintFactory factory; | 376 MockConstraintFactory factory; |
384 factory.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 25); | 377 factory.basic().frameRate.setMin(25); |
385 factory.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 15); | 378 factory.basic().frameRate.setMax(15); |
386 blink::WebMediaStreamTrack track = CreateTrack( | 379 blink::WebMediaStreamTrack track = CreateTrack( |
387 "123", factory.CreateWebMediaConstraints()); | 380 "123", factory.CreateWebMediaConstraints()); |
388 mock_source()->CompleteGetSupportedFormats(); | 381 mock_source()->CompleteGetSupportedFormats(); |
389 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 382 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
390 } | 383 } |
391 | 384 |
392 // Test that its safe to release the last reference of a blink track and the | 385 // Test that its safe to release the last reference of a blink track and the |
393 // source during the callback if adding a track succeeds. | 386 // source during the callback if adding a track succeeds. |
394 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnSuccessCallBack) { | 387 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnSuccessCallBack) { |
395 MockMediaConstraintFactory factory; | 388 MockConstraintFactory factory; |
396 { | 389 { |
397 blink::WebMediaStreamTrack track = | 390 blink::WebMediaStreamTrack track = |
398 CreateTrack("123", factory.CreateWebMediaConstraints()); | 391 CreateTrack("123", factory.CreateWebMediaConstraints()); |
399 ReleaseTrackAndSourceOnAddTrackCallback(track); | 392 ReleaseTrackAndSourceOnAddTrackCallback(track); |
400 } | 393 } |
401 mock_source()->CompleteGetSupportedFormats(); | 394 mock_source()->CompleteGetSupportedFormats(); |
402 mock_source()->StartMockedSource(); | 395 mock_source()->StartMockedSource(); |
403 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 396 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
404 } | 397 } |
405 | 398 |
406 // Test that its safe to release the last reference of a blink track and the | 399 // Test that its safe to release the last reference of a blink track and the |
407 // source during the callback if adding a track fails. | 400 // source during the callback if adding a track fails. |
408 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnFailureCallBack) { | 401 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnFailureCallBack) { |
409 MockMediaConstraintFactory factory; | 402 MockConstraintFactory factory; |
410 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 99999); | 403 factory.basic().width.setMin(99999); |
411 { | 404 { |
412 blink::WebMediaStreamTrack track = | 405 blink::WebMediaStreamTrack track = |
413 CreateTrack("123", factory.CreateWebMediaConstraints()); | 406 CreateTrack("123", factory.CreateWebMediaConstraints()); |
414 ReleaseTrackAndSourceOnAddTrackCallback(track); | 407 ReleaseTrackAndSourceOnAddTrackCallback(track); |
415 } | 408 } |
416 mock_source()->CompleteGetSupportedFormats(); | 409 mock_source()->CompleteGetSupportedFormats(); |
417 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 410 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
418 } | 411 } |
419 | 412 |
420 // Test that the source ignores an optional aspect ratio that is higher than | 413 // Test that the source ignores an optional aspect ratio that is higher than |
421 // supported. | 414 // supported. |
422 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHigh) { | 415 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHigh) { |
423 MockMediaConstraintFactory factory; | 416 MockConstraintFactory factory; |
424 factory.AddOptional(MediaStreamVideoSource::kMinAspectRatio, 2); | 417 factory.AddAdvanced().aspectRatio.setMin(2.0); |
425 blink::WebMediaStreamTrack track = CreateTrack( | 418 blink::WebMediaStreamTrack track = CreateTrack( |
426 "123", factory.CreateWebMediaConstraints()); | 419 "123", factory.CreateWebMediaConstraints()); |
427 mock_source()->CompleteGetSupportedFormats(); | 420 mock_source()->CompleteGetSupportedFormats(); |
428 | 421 |
429 const media::VideoCaptureFormat& format = mock_source()->start_format(); | 422 const media::VideoCaptureFormat& format = mock_source()->start_format(); |
430 const double aspect_ratio = static_cast<double>(format.frame_size.width()) / | 423 const double aspect_ratio = static_cast<double>(format.frame_size.width()) / |
431 format.frame_size.height(); | 424 format.frame_size.height(); |
432 EXPECT_LT(aspect_ratio, 2); | 425 EXPECT_LT(aspect_ratio, 2); |
433 } | 426 } |
434 | 427 |
(...skipping 10 matching lines...) Expand all Loading... |
445 | 438 |
446 blink::WebMediaConstraints constraints; | 439 blink::WebMediaConstraints constraints; |
447 constraints.initialize(); | 440 constraints.initialize(); |
448 CreateTrackAndStartSource(constraints, | 441 CreateTrackAndStartSource(constraints, |
449 MediaStreamVideoSource::kDefaultWidth, | 442 MediaStreamVideoSource::kDefaultWidth, |
450 MediaStreamVideoSource::kDefaultHeight, | 443 MediaStreamVideoSource::kDefaultHeight, |
451 30); | 444 30); |
452 } | 445 } |
453 | 446 |
454 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) { | 447 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) { |
455 MockMediaConstraintFactory factory; | 448 MockConstraintFactory factory; |
456 factory.AddMandatory("weird key", 640); | 449 // Use a constraint that is only known for audio. |
| 450 factory.basic().echoCancellation.setExact(true); |
457 blink::WebMediaStreamTrack track = CreateTrack( | 451 blink::WebMediaStreamTrack track = CreateTrack( |
458 "123", factory.CreateWebMediaConstraints()); | 452 "123", factory.CreateWebMediaConstraints()); |
459 mock_source()->CompleteGetSupportedFormats(); | 453 mock_source()->CompleteGetSupportedFormats(); |
460 EXPECT_EQ(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED, error_type()); | 454 EXPECT_EQ(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED, error_type()); |
461 EXPECT_EQ("weird key", error_name()); | 455 EXPECT_EQ("echoCancellation", error_name()); |
462 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 456 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
463 } | 457 } |
464 | 458 |
465 // Test that the source ignores an unknown optional constraint. | 459 // Test that the source ignores an unknown optional constraint. |
466 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) { | 460 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) { |
467 MockMediaConstraintFactory factory; | 461 MockConstraintFactory factory; |
468 factory.AddOptional("weird key", 640); | 462 factory.AddAdvanced().echoCancellation.setExact(true); |
469 | 463 |
470 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), | 464 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), |
471 MediaStreamVideoSource::kDefaultWidth, | 465 MediaStreamVideoSource::kDefaultWidth, |
472 MediaStreamVideoSource::kDefaultHeight, | 466 MediaStreamVideoSource::kDefaultHeight, |
473 30); | 467 30); |
474 } | 468 } |
475 | 469 |
476 // Tests that the source starts video with the max width and height set by | 470 // Tests that the source starts video with the max width and height set by |
477 // constraints for screencast. | 471 // constraints for screencast. |
478 TEST_F(MediaStreamVideoSourceTest, ScreencastResolutionWithConstraint) { | 472 TEST_F(MediaStreamVideoSourceTest, ScreencastResolutionWithConstraint) { |
479 media::VideoCaptureFormats formats; | 473 media::VideoCaptureFormats formats; |
480 formats.push_back(media::VideoCaptureFormat( | 474 formats.push_back(media::VideoCaptureFormat( |
481 gfx::Size(480, 270), 30, media::PIXEL_FORMAT_I420)); | 475 gfx::Size(480, 270), 30, media::PIXEL_FORMAT_I420)); |
482 mock_source()->SetSupportedFormats(formats); | 476 mock_source()->SetSupportedFormats(formats); |
483 MockMediaConstraintFactory factory; | 477 MockConstraintFactory factory; |
484 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 480); | 478 factory.basic().width.setMax(480); |
485 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 270); | 479 factory.basic().height.setMax(270); |
486 | 480 |
487 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( | 481 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( |
488 factory.CreateWebMediaConstraints(), 480, 270, 30); | 482 factory.CreateWebMediaConstraints(), 480, 270, 30); |
489 EXPECT_EQ(480, mock_source()->max_requested_height()); | 483 EXPECT_EQ(480, mock_source()->max_requested_height()); |
490 EXPECT_EQ(270, mock_source()->max_requested_width()); | 484 EXPECT_EQ(270, mock_source()->max_requested_width()); |
491 } | 485 } |
492 | 486 |
493 // Test that optional constraints are applied in order. | 487 // Test that optional constraints are applied in order. |
494 TEST_F(MediaStreamVideoSourceTest, OptionalConstraints) { | 488 TEST_F(MediaStreamVideoSourceTest, OptionalConstraints) { |
495 MockMediaConstraintFactory factory; | 489 MockConstraintFactory factory; |
496 // Min width of 2056 pixels can not be fulfilled. | 490 // Min width of 2056 pixels can not be fulfilled. |
497 factory.AddOptional(MediaStreamVideoSource::kMinWidth, 2056); | 491 factory.AddAdvanced().width.setMin(2056); |
498 factory.AddOptional(MediaStreamVideoSource::kMinWidth, 641); | 492 factory.AddAdvanced().width.setMin(641); |
499 // Since min width is set to 641 pixels, max width 640 can not be fulfilled. | 493 // Since min width is set to 641 pixels, max width 640 can not be fulfilled. |
500 factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 640); | 494 factory.AddAdvanced().width.setMax(640); |
501 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); | 495 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); |
502 } | 496 } |
503 | 497 |
504 // Test that the source crops to the requested max width and | 498 // Test that the source crops to the requested max width and |
505 // height even though the camera delivers a larger frame. | 499 // height even though the camera delivers a larger frame. |
506 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameOptional640360) { | 500 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameOptional640360) { |
507 MockMediaConstraintFactory factory; | 501 MockConstraintFactory factory; |
508 factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 640); | 502 factory.AddAdvanced().width.setMax(640); |
509 factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 360); | 503 factory.AddAdvanced().height.setMax(360); |
510 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); | 504 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); |
511 } | 505 } |
512 | 506 |
513 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory640360) { | 507 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory640360) { |
514 MockMediaConstraintFactory factory; | 508 MockConstraintFactory factory; |
515 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 640); | 509 factory.basic().width.setMax(640); |
516 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360); | 510 factory.basic().height.setMax(360); |
517 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); | 511 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); |
518 } | 512 } |
519 | 513 |
520 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory732489) { | 514 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory732489) { |
521 MockMediaConstraintFactory factory; | 515 MockConstraintFactory factory; |
522 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 732); | 516 factory.basic().width.setMax(732); |
523 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 489); | 517 factory.basic().height.setMax(489); |
524 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 732); | 518 factory.basic().width.setMin(732); |
525 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 489); | 519 factory.basic().height.setMin(489); |
526 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 732, 489); | 520 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 732, 489); |
527 } | 521 } |
528 | 522 |
529 // Test that the source crops to the requested max width and | 523 // Test that the source crops to the requested max width and |
530 // height even though the requested frame has odd size. | 524 // height even though the requested frame has odd size. |
531 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame637359) { | 525 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame637359) { |
532 MockMediaConstraintFactory factory; | 526 MockConstraintFactory factory; |
533 factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 637); | 527 factory.AddAdvanced().width.setMax(637); |
534 factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 359); | 528 factory.AddAdvanced().height.setMax(359); |
535 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 637, 359); | 529 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 637, 359); |
536 } | 530 } |
537 | 531 |
538 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame320320) { | 532 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame320320) { |
539 MockMediaConstraintFactory factory; | 533 MockConstraintFactory factory; |
540 factory.AddMandatory(MediaStreamVideoSource::kMaxWidth, 320); | 534 factory.basic().width.setMax(320); |
541 factory.AddMandatory(MediaStreamVideoSource::kMaxHeight, 320); | 535 factory.basic().height.setMax(320); |
542 factory.AddMandatory(MediaStreamVideoSource::kMinHeight, 320); | 536 factory.basic().height.setMin(320); |
543 factory.AddMandatory(MediaStreamVideoSource::kMinWidth, 320); | 537 factory.basic().width.setMax(320); |
544 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 320, 320); | 538 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 320, 320); |
545 } | 539 } |
546 | 540 |
547 TEST_F(MediaStreamVideoSourceTest, DeliverSmallerSizeWhenTooLargeMax) { | 541 TEST_F(MediaStreamVideoSourceTest, DeliverSmallerSizeWhenTooLargeMax) { |
548 MockMediaConstraintFactory factory; | 542 MockConstraintFactory factory; |
549 factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 1920); | 543 factory.AddAdvanced().width.setMax(1920); |
550 factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 1080); | 544 factory.AddAdvanced().height.setMax(1080); |
551 factory.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 545 factory.AddAdvanced().width.setMin(1280); |
552 factory.AddOptional(MediaStreamVideoSource::kMinHeight, 720); | 546 factory.AddAdvanced().height.setMin(720); |
553 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), | 547 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), |
554 1280, 720); | 548 1280, 720); |
555 } | 549 } |
556 | 550 |
557 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) { | 551 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) { |
558 MockMediaConstraintFactory factory1; | 552 MockConstraintFactory factory1; |
559 factory1.AddOptional(MediaStreamVideoSource::kMaxWidth, 640); | 553 factory1.AddAdvanced().width.setMax(640); |
560 factory1.AddOptional(MediaStreamVideoSource::kMaxHeight, 480); | 554 factory1.AddAdvanced().height.setMax(480); |
561 | 555 |
562 MockMediaConstraintFactory factory2; | 556 MockConstraintFactory factory2; |
563 factory2.AddOptional(MediaStreamVideoSource::kMaxHeight, 360); | 557 factory2.AddAdvanced().height.setMax(360); |
564 | 558 |
565 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 559 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
566 factory2.CreateWebMediaConstraints(), | 560 factory2.CreateWebMediaConstraints(), |
567 640, 480, | 561 640, 480, |
568 640, 480, | 562 640, 480, |
569 640, 360); | 563 640, 360); |
570 } | 564 } |
571 | 565 |
572 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) { | 566 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) { |
573 MockMediaConstraintFactory factory1; | 567 MockConstraintFactory factory1; |
574 factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 568 factory1.AddAdvanced().width.setMin(1280); |
575 factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720); | 569 factory1.AddAdvanced().height.setMin(720); |
576 | 570 |
577 | 571 MockConstraintFactory factory2; |
578 MockMediaConstraintFactory factory2; | 572 factory2.basic().width.setMax(640); |
579 factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 640); | 573 factory2.basic().height.setMax(360); |
580 factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 360); | |
581 | 574 |
582 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 575 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
583 factory2.CreateWebMediaConstraints(), | 576 factory2.CreateWebMediaConstraints(), |
584 1280, 720, | 577 1280, 720, |
585 1280, 720, | 578 1280, 720, |
586 640, 360); | 579 640, 360); |
587 } | 580 } |
588 | 581 |
589 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndW700H700) { | 582 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndW700H700) { |
590 MockMediaConstraintFactory factory1; | 583 MockConstraintFactory factory1; |
591 factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 584 factory1.AddAdvanced().width.setMin(1280); |
592 factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720); | 585 factory1.AddAdvanced().height.setMin(720); |
593 | 586 |
594 MockMediaConstraintFactory factory2; | 587 MockConstraintFactory factory2; |
595 factory2.AddMandatory(MediaStreamVideoSource::kMaxWidth, 700); | 588 factory2.basic().width.setMax(700); |
596 factory2.AddMandatory(MediaStreamVideoSource::kMaxHeight, 700); | 589 factory2.basic().height.setMax(700); |
597 | 590 |
598 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 591 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
599 factory2.CreateWebMediaConstraints(), | 592 factory2.CreateWebMediaConstraints(), |
600 1280, 720, | 593 1280, 720, |
601 1280, 720, | 594 1280, 720, |
602 700, 700); | 595 700, 700); |
603 } | 596 } |
604 | 597 |
605 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndMaxAspectRatio4To3) { | 598 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndMaxAspectRatio4To3) { |
606 MockMediaConstraintFactory factory1; | 599 MockConstraintFactory factory1; |
607 factory1.AddOptional(MediaStreamVideoSource::kMinWidth, 1280); | 600 factory1.AddAdvanced().width.setMin(1280); |
608 factory1.AddOptional(MediaStreamVideoSource::kMinHeight, 720); | 601 factory1.AddAdvanced().height.setMin(720); |
609 | 602 |
610 MockMediaConstraintFactory factory2; | 603 MockConstraintFactory factory2; |
611 factory2.AddMandatory(MediaStreamVideoSource::kMaxAspectRatio, 640.0 / 480); | 604 factory2.basic().aspectRatio.setMax(640.0 / 480); |
612 | 605 |
613 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 606 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
614 factory2.CreateWebMediaConstraints(), | 607 factory2.CreateWebMediaConstraints(), |
615 1280, 720, | 608 1280, 720, |
616 1280, 720, | 609 1280, 720, |
617 960, 720); | 610 960, 720); |
618 } | 611 } |
619 | 612 |
620 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVgaAndMinAspectRatio) { | 613 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVgaAndMinAspectRatio) { |
621 MockMediaConstraintFactory factory1; | 614 MockConstraintFactory factory1; |
622 factory1.AddOptional(MediaStreamVideoSource::kMaxWidth, 640); | 615 factory1.AddAdvanced().width.setMax(640); |
623 factory1.AddOptional(MediaStreamVideoSource::kMaxHeight, 480); | 616 factory1.AddAdvanced().height.setMax(480); |
624 | 617 |
625 MockMediaConstraintFactory factory2; | 618 MockConstraintFactory factory2; |
626 factory2.AddMandatory(MediaStreamVideoSource::kMinAspectRatio, 640.0 / 360); | 619 factory2.basic().aspectRatio.setMin(640.0 / 360); |
627 | 620 |
628 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 621 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
629 factory2.CreateWebMediaConstraints(), | 622 factory2.CreateWebMediaConstraints(), |
630 640, 480, | 623 640, 480, |
631 640, 480, | 624 640, 480, |
632 640, 360); | 625 640, 360); |
633 } | 626 } |
634 | 627 |
635 TEST_F(MediaStreamVideoSourceTest, | 628 TEST_F(MediaStreamVideoSourceTest, |
636 TwoTracksWithSecondTrackFrameRateHigherThanFirst) { | 629 TwoTracksWithSecondTrackFrameRateHigherThanFirst) { |
637 MockMediaConstraintFactory factory1; | 630 MockConstraintFactory factory1; |
638 factory1.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 15); | 631 factory1.basic().frameRate.setMin(15); |
639 factory1.AddMandatory(MediaStreamVideoSource::kMaxFrameRate, 15); | 632 factory1.basic().frameRate.setMax(15); |
640 | 633 |
641 blink::WebMediaStreamTrack track1 = | 634 blink::WebMediaStreamTrack track1 = |
642 CreateTrackAndStartSource(factory1.CreateWebMediaConstraints(), | 635 CreateTrackAndStartSource(factory1.CreateWebMediaConstraints(), |
643 MediaStreamVideoSource::kDefaultWidth, | 636 MediaStreamVideoSource::kDefaultWidth, |
644 MediaStreamVideoSource::kDefaultHeight, | 637 MediaStreamVideoSource::kDefaultHeight, |
645 15); | 638 15); |
646 | 639 |
647 MockMediaConstraintFactory factory2; | 640 MockConstraintFactory factory2; |
648 factory2.AddMandatory(MediaStreamVideoSource::kMinFrameRate, 30); | 641 factory2.basic().frameRate.setMin(30); |
649 blink::WebMediaStreamTrack track2 = CreateTrack( | 642 blink::WebMediaStreamTrack track2 = CreateTrack( |
650 "123", factory2.CreateWebMediaConstraints()); | 643 "123", factory2.CreateWebMediaConstraints()); |
651 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 644 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
652 } | 645 } |
653 | 646 |
654 // Test that a source can change the frame resolution on the fly and that | 647 // Test that a source can change the frame resolution on the fly and that |
655 // tracks sinks get the new frame size unless constraints force the frame to be | 648 // tracks sinks get the new frame size unless constraints force the frame to be |
656 // cropped. | 649 // cropped. |
657 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) { | 650 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) { |
658 MockMediaConstraintFactory factory; | 651 MockConstraintFactory factory; |
659 factory.AddOptional(MediaStreamVideoSource::kMaxWidth, 800); | 652 factory.AddAdvanced().width.setMax(800); |
660 factory.AddOptional(MediaStreamVideoSource::kMaxHeight, 700); | 653 factory.AddAdvanced().height.setMax(700); |
661 | 654 |
662 // Expect the source to start capture with the supported resolution. | 655 // Expect the source to start capture with the supported resolution. |
663 blink::WebMediaStreamTrack track = | 656 blink::WebMediaStreamTrack track = |
664 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), | 657 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), |
665 640, 480, 30); | 658 640, 480, 30); |
666 | 659 |
667 MockMediaStreamVideoSink sink; | 660 MockMediaStreamVideoSink sink; |
668 MediaStreamVideoSink::AddToVideoTrack( | 661 MediaStreamVideoSink::AddToVideoTrack( |
669 &sink, sink.GetDeliverFrameCB(), track); | 662 &sink, sink.GetDeliverFrameCB(), track); |
670 EXPECT_EQ(0, sink.number_of_frames()); | 663 EXPECT_EQ(0, sink.number_of_frames()); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
739 // Expect the delivered frame to be passed unchanged since its smaller than | 732 // Expect the delivered frame to be passed unchanged since its smaller than |
740 // max requested. | 733 // max requested. |
741 EXPECT_EQ(320, sink.frame_size().width()); | 734 EXPECT_EQ(320, sink.frame_size().width()); |
742 EXPECT_EQ(240, sink.frame_size().height()); | 735 EXPECT_EQ(240, sink.frame_size().height()); |
743 MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track); | 736 MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track); |
744 } | 737 } |
745 | 738 |
746 // Test that a source producing no frames change the source readyState to muted. | 739 // Test that a source producing no frames change the source readyState to muted. |
747 // that in a reasonable time frame the muted state turns to false. | 740 // that in a reasonable time frame the muted state turns to false. |
748 TEST_F(MediaStreamVideoSourceTest, MutedSource) { | 741 TEST_F(MediaStreamVideoSourceTest, MutedSource) { |
749 // Setup the source for support a frame rate of 2000fps in order to test | 742 // Setup the source for support a frame rate of 999 fps in order to test |
750 // the muted event faster. This is since the frame monitoring uses | 743 // the muted event faster. This is since the frame monitoring uses |
751 // PostDelayedTask that is dependent on the source frame rate. | 744 // PostDelayedTask that is dependent on the source frame rate. |
| 745 // Note that media::limits::kMaxFramesPerSecond is 1000. |
752 media::VideoCaptureFormats formats; | 746 media::VideoCaptureFormats formats; |
753 formats.push_back(media::VideoCaptureFormat( | 747 formats.push_back(media::VideoCaptureFormat( |
754 gfx::Size(640, 480), 2000, media::PIXEL_FORMAT_I420)); | 748 gfx::Size(640, 480), media::limits::kMaxFramesPerSecond - 1, |
| 749 media::PIXEL_FORMAT_I420)); |
755 SetSourceSupportedFormats(formats); | 750 SetSourceSupportedFormats(formats); |
756 | 751 |
757 MockMediaConstraintFactory factory; | 752 MockConstraintFactory factory; |
758 blink::WebMediaStreamTrack track = | 753 blink::WebMediaStreamTrack track = |
759 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), | 754 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480, |
760 640, 480, 2000); | 755 media::limits::kMaxFramesPerSecond - 1); |
761 MockMediaStreamVideoSink sink; | 756 MockMediaStreamVideoSink sink; |
762 MediaStreamVideoSink::AddToVideoTrack(&sink, sink.GetDeliverFrameCB(), track); | 757 MediaStreamVideoSink::AddToVideoTrack(&sink, sink.GetDeliverFrameCB(), track); |
763 EXPECT_EQ(track.source().readyState(), | 758 EXPECT_EQ(track.source().readyState(), |
764 blink::WebMediaStreamSource::ReadyStateLive); | 759 blink::WebMediaStreamSource::ReadyStateLive); |
765 | 760 |
766 base::RunLoop run_loop; | 761 base::RunLoop run_loop; |
767 base::Closure quit_closure = run_loop.QuitClosure(); | 762 base::Closure quit_closure = run_loop.QuitClosure(); |
768 bool muted_state = false; | 763 bool muted_state = false; |
769 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) | 764 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) |
770 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure))); | 765 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure))); |
(...skipping 11 matching lines...) Expand all Loading... |
782 run_loop2.Run(); | 777 run_loop2.Run(); |
783 | 778 |
784 EXPECT_EQ(muted_state, false); | 779 EXPECT_EQ(muted_state, false); |
785 EXPECT_EQ(track.source().readyState(), | 780 EXPECT_EQ(track.source().readyState(), |
786 blink::WebMediaStreamSource::ReadyStateLive); | 781 blink::WebMediaStreamSource::ReadyStateLive); |
787 | 782 |
788 MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track); | 783 MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track); |
789 } | 784 } |
790 | 785 |
791 } // namespace content | 786 } // namespace content |
OLD | NEW |