Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(15)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: webrtc/media/base/videoadapter_unittest.cc

Issue 1973873003: Delete AndroidVideoCapturer::FrameFactory. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Delete left-over prototype. Revert a comment change. Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« webrtc/common_video/video_frame_buffer.cc ('K') | « webrtc/media/base/videoadapter.cc ('k') | webrtc/media/base/videocapturer.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2010 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2010 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source 5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
65 65
66 void OnFrameCaptured(VideoCapturer* capturer, 66 void OnFrameCaptured(VideoCapturer* capturer,
67 const CapturedFrame* captured_frame) { 67 const CapturedFrame* captured_frame) {
68 rtc::CritScope lock(&crit_); 68 rtc::CritScope lock(&crit_);
69 const int in_width = captured_frame->width; 69 const int in_width = captured_frame->width;
70 const int in_height = abs(captured_frame->height); 70 const int in_height = abs(captured_frame->height);
71 int cropped_width; 71 int cropped_width;
72 int cropped_height; 72 int cropped_height;
73 int out_width; 73 int out_width;
74 int out_height; 74 int out_height;
75 video_adapter_->AdaptFrameResolution(in_width, in_height, 75 if (video_adapter_->AdaptFrameResolution(in_width, in_height,
76 &cropped_width, &cropped_height, 76 &cropped_width, &cropped_height,
77 &out_width, &out_height); 77 &out_width, &out_height)) {
78 if (out_width != 0 && out_height != 0) {
79 cropped_width_ = cropped_width; 78 cropped_width_ = cropped_width;
80 cropped_height_ = cropped_height; 79 cropped_height_ = cropped_height;
81 out_width_ = out_width; 80 out_width_ = out_width;
82 out_height_ = out_height; 81 out_height_ = out_height;
83 last_adapt_was_no_op_ = 82 last_adapt_was_no_op_ =
84 (in_width == cropped_width && in_height == cropped_height && 83 (in_width == cropped_width && in_height == cropped_height &&
85 in_width == out_width && in_height == out_height); 84 in_width == out_width && in_height == out_height);
86 } else { 85 } else {
87 ++dropped_frames_; 86 ++dropped_frames_;
88 } 87 }
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after
229 EXPECT_GT(listener_->GetStats().dropped_frames, 0); 228 EXPECT_GT(listener_->GetStats().dropped_frames, 0);
230 } 229 }
231 230
232 // Set a very high output pixel resolution. Expect no cropping or resolution 231 // Set a very high output pixel resolution. Expect no cropping or resolution
233 // change. 232 // change.
234 TEST_F(VideoAdapterTest, AdaptFrameResolutionHighLimit) { 233 TEST_F(VideoAdapterTest, AdaptFrameResolutionHighLimit) {
235 VideoFormat output_format = capture_format_; 234 VideoFormat output_format = capture_format_;
236 output_format.width *= 10; 235 output_format.width *= 10;
237 output_format.height *= 10; 236 output_format.height *= 10;
238 adapter_.OnOutputFormatRequest(output_format); 237 adapter_.OnOutputFormatRequest(output_format);
239 adapter_.AdaptFrameResolution(capture_format_.width, capture_format_.height, 238 EXPECT_TRUE(adapter_.AdaptFrameResolution(
240 &cropped_width_, &cropped_height_, 239 capture_format_.width, capture_format_.height,
241 &out_width_, &out_height_); 240 &cropped_width_, &cropped_height_,
241 &out_width_, &out_height_));
242 EXPECT_EQ(capture_format_.width, cropped_width_); 242 EXPECT_EQ(capture_format_.width, cropped_width_);
243 EXPECT_EQ(capture_format_.height, cropped_height_); 243 EXPECT_EQ(capture_format_.height, cropped_height_);
244 EXPECT_EQ(capture_format_.width, out_width_); 244 EXPECT_EQ(capture_format_.width, out_width_);
245 EXPECT_EQ(capture_format_.height, out_height_); 245 EXPECT_EQ(capture_format_.height, out_height_);
246 } 246 }
247 247
248 // Adapt the frame resolution to be the same as capture resolution. Expect no 248 // Adapt the frame resolution to be the same as capture resolution. Expect no
249 // cropping or resolution change. 249 // cropping or resolution change.
250 TEST_F(VideoAdapterTest, AdaptFrameResolutionIdentical) { 250 TEST_F(VideoAdapterTest, AdaptFrameResolutionIdentical) {
251 adapter_.OnOutputFormatRequest(capture_format_); 251 adapter_.OnOutputFormatRequest(capture_format_);
252 adapter_.AdaptFrameResolution(capture_format_.width, capture_format_.height, 252 EXPECT_TRUE(adapter_.AdaptFrameResolution(
253 &cropped_width_, &cropped_height_, 253 capture_format_.width, capture_format_.height,
254 &out_width_, &out_height_); 254 &cropped_width_, &cropped_height_,
255 &out_width_, &out_height_));
255 EXPECT_EQ(capture_format_.width, cropped_width_); 256 EXPECT_EQ(capture_format_.width, cropped_width_);
256 EXPECT_EQ(capture_format_.height, cropped_height_); 257 EXPECT_EQ(capture_format_.height, cropped_height_);
257 EXPECT_EQ(capture_format_.width, out_width_); 258 EXPECT_EQ(capture_format_.width, out_width_);
258 EXPECT_EQ(capture_format_.height, out_height_); 259 EXPECT_EQ(capture_format_.height, out_height_);
259 } 260 }
260 261
261 // Adapt the frame resolution to be a quarter of the capture resolution. Expect 262 // Adapt the frame resolution to be a quarter of the capture resolution. Expect
262 // no cropping, but a resolution change. 263 // no cropping, but a resolution change.
263 TEST_F(VideoAdapterTest, AdaptFrameResolutionQuarter) { 264 TEST_F(VideoAdapterTest, AdaptFrameResolutionQuarter) {
264 VideoFormat request_format = capture_format_; 265 VideoFormat request_format = capture_format_;
265 request_format.width /= 2; 266 request_format.width /= 2;
266 request_format.height /= 2; 267 request_format.height /= 2;
267 adapter_.OnOutputFormatRequest(request_format); 268 adapter_.OnOutputFormatRequest(request_format);
268 adapter_.AdaptFrameResolution(capture_format_.width, capture_format_.height, 269 EXPECT_TRUE(adapter_.AdaptFrameResolution(
269 &cropped_width_, &cropped_height_, 270 capture_format_.width, capture_format_.height,
270 &out_width_, &out_height_); 271 &cropped_width_, &cropped_height_,
272 &out_width_, &out_height_));
271 EXPECT_EQ(capture_format_.width, cropped_width_); 273 EXPECT_EQ(capture_format_.width, cropped_width_);
272 EXPECT_EQ(capture_format_.height, cropped_height_); 274 EXPECT_EQ(capture_format_.height, cropped_height_);
273 EXPECT_EQ(request_format.width, out_width_); 275 EXPECT_EQ(request_format.width, out_width_);
274 EXPECT_EQ(request_format.height, out_height_); 276 EXPECT_EQ(request_format.height, out_height_);
275 } 277 }
276 278
277 // Adapt the pixel resolution to 0. Expect frame drop. 279 // Adapt the pixel resolution to 0. Expect frame drop.
278 TEST_F(VideoAdapterTest, AdaptFrameResolutionDrop) { 280 TEST_F(VideoAdapterTest, AdaptFrameResolutionDrop) {
279 VideoFormat output_format = capture_format_; 281 VideoFormat output_format = capture_format_;
280 output_format.width = 0; 282 output_format.width = 0;
281 output_format.height = 0; 283 output_format.height = 0;
282 adapter_.OnOutputFormatRequest(output_format); 284 adapter_.OnOutputFormatRequest(output_format);
283 adapter_.AdaptFrameResolution(capture_format_.width, capture_format_.height, 285 EXPECT_FALSE(adapter_.AdaptFrameResolution(
284 &cropped_width_, &cropped_height_, 286 capture_format_.width, capture_format_.height,
285 &out_width_, &out_height_); 287 &cropped_width_, &cropped_height_,
286 EXPECT_EQ(0, out_width_); 288 &out_width_, &out_height_));
287 EXPECT_EQ(0, out_height_);
288 } 289 }
289 290
290 // Adapt the frame resolution to be a quarter of the capture resolution at the 291 // Adapt the frame resolution to be a quarter of the capture resolution at the
291 // beginning. Expect no cropping but a resolution change. 292 // beginning. Expect no cropping but a resolution change.
292 TEST_F(VideoAdapterTest, AdaptResolution) { 293 TEST_F(VideoAdapterTest, AdaptResolution) {
293 VideoFormat request_format = capture_format_; 294 VideoFormat request_format = capture_format_;
294 request_format.width /= 2; 295 request_format.width /= 2;
295 request_format.height /= 2; 296 request_format.height /= 2;
296 adapter_.OnOutputFormatRequest(request_format); 297 adapter_.OnOutputFormatRequest(request_format);
297 EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_)); 298 EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
343 344
344 // Verify all frames are dropped. 345 // Verify all frames are dropped.
345 VideoCapturerListener::Stats stats = listener_->GetStats(); 346 VideoCapturerListener::Stats stats = listener_->GetStats();
346 EXPECT_GE(stats.captured_frames, 10); 347 EXPECT_GE(stats.captured_frames, 10);
347 EXPECT_EQ(stats.captured_frames, stats.dropped_frames); 348 EXPECT_EQ(stats.captured_frames, stats.dropped_frames);
348 } 349 }
349 350
350 TEST_F(VideoAdapterTest, TestOnOutputFormatRequest) { 351 TEST_F(VideoAdapterTest, TestOnOutputFormatRequest) {
351 VideoFormat format(640, 400, VideoFormat::FpsToInterval(30), 0); 352 VideoFormat format(640, 400, VideoFormat::FpsToInterval(30), 0);
352 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 353 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
353 adapter_.AdaptFrameResolution(640, 400, 354 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
354 &cropped_width_, &cropped_height_, 355 &cropped_width_, &cropped_height_,
355 &out_width_, &out_height_); 356 &out_width_, &out_height_));
356 EXPECT_EQ(640, cropped_width_); 357 EXPECT_EQ(640, cropped_width_);
357 EXPECT_EQ(400, cropped_height_); 358 EXPECT_EQ(400, cropped_height_);
358 EXPECT_EQ(640, out_width_); 359 EXPECT_EQ(640, out_width_);
359 EXPECT_EQ(400, out_height_); 360 EXPECT_EQ(400, out_height_);
360 361
361 // Format request 640x400. 362 // Format request 640x400.
362 format.height = 400; 363 format.height = 400;
363 adapter_.OnOutputFormatRequest(format); 364 adapter_.OnOutputFormatRequest(format);
364 adapter_.AdaptFrameResolution(640, 400, 365 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
365 &cropped_width_, &cropped_height_, 366 &cropped_width_, &cropped_height_,
366 &out_width_, &out_height_); 367 &out_width_, &out_height_));
367 EXPECT_EQ(640, cropped_width_); 368 EXPECT_EQ(640, cropped_width_);
368 EXPECT_EQ(400, cropped_height_); 369 EXPECT_EQ(400, cropped_height_);
369 EXPECT_EQ(640, out_width_); 370 EXPECT_EQ(640, out_width_);
370 EXPECT_EQ(400, out_height_); 371 EXPECT_EQ(400, out_height_);
371 372
372 // Request 1280x720, higher than input, but aspect 16:9. Expect cropping but 373 // Request 1280x720, higher than input, but aspect 16:9. Expect cropping but
373 // no scaling. 374 // no scaling.
374 format.width = 1280; 375 format.width = 1280;
375 format.height = 720; 376 format.height = 720;
376 adapter_.OnOutputFormatRequest(format); 377 adapter_.OnOutputFormatRequest(format);
377 adapter_.AdaptFrameResolution(640, 400, 378 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
378 &cropped_width_, &cropped_height_, 379 &cropped_width_, &cropped_height_,
379 &out_width_, &out_height_); 380 &out_width_, &out_height_));
380 EXPECT_EQ(640, cropped_width_); 381 EXPECT_EQ(640, cropped_width_);
381 EXPECT_EQ(360, cropped_height_); 382 EXPECT_EQ(360, cropped_height_);
382 EXPECT_EQ(640, out_width_); 383 EXPECT_EQ(640, out_width_);
383 EXPECT_EQ(360, out_height_); 384 EXPECT_EQ(360, out_height_);
384 385
385 // Request 0x0. 386 // Request 0x0.
386 format.width = 0; 387 format.width = 0;
387 format.height = 0; 388 format.height = 0;
388 adapter_.OnOutputFormatRequest(format); 389 adapter_.OnOutputFormatRequest(format);
389 adapter_.AdaptFrameResolution(640, 400, 390 EXPECT_FALSE(adapter_.AdaptFrameResolution(640, 400,
390 &cropped_width_, &cropped_height_, 391 &cropped_width_, &cropped_height_,
391 &out_width_, &out_height_); 392 &out_width_, &out_height_));
392 EXPECT_EQ(0, out_width_);
393 EXPECT_EQ(0, out_height_);
394 393
395 // Request 320x200. Expect scaling, but no cropping. 394 // Request 320x200. Expect scaling, but no cropping.
396 format.width = 320; 395 format.width = 320;
397 format.height = 200; 396 format.height = 200;
398 adapter_.OnOutputFormatRequest(format); 397 adapter_.OnOutputFormatRequest(format);
399 adapter_.AdaptFrameResolution(640, 400, 398 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
400 &cropped_width_, &cropped_height_, 399 &cropped_width_, &cropped_height_,
401 &out_width_, &out_height_); 400 &out_width_, &out_height_));
402 EXPECT_EQ(640, cropped_width_); 401 EXPECT_EQ(640, cropped_width_);
403 EXPECT_EQ(400, cropped_height_); 402 EXPECT_EQ(400, cropped_height_);
404 EXPECT_EQ(320, out_width_); 403 EXPECT_EQ(320, out_width_);
405 EXPECT_EQ(200, out_height_); 404 EXPECT_EQ(200, out_height_);
406 405
407 // Request resolution close to 2/3 scale. Expect adapt down. Scaling to 2/3 406 // Request resolution close to 2/3 scale. Expect adapt down. Scaling to 2/3
408 // is not optimized and not allowed, therefore 1/2 scaling will be used 407 // is not optimized and not allowed, therefore 1/2 scaling will be used
409 // instead. 408 // instead.
410 format.width = 424; 409 format.width = 424;
411 format.height = 265; 410 format.height = 265;
412 adapter_.OnOutputFormatRequest(format); 411 adapter_.OnOutputFormatRequest(format);
413 adapter_.AdaptFrameResolution(640, 400, 412 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
414 &cropped_width_, &cropped_height_, 413 &cropped_width_, &cropped_height_,
415 &out_width_, &out_height_); 414 &out_width_, &out_height_));
416 EXPECT_EQ(640, cropped_width_); 415 EXPECT_EQ(640, cropped_width_);
417 EXPECT_EQ(400, cropped_height_); 416 EXPECT_EQ(400, cropped_height_);
418 EXPECT_EQ(320, out_width_); 417 EXPECT_EQ(320, out_width_);
419 EXPECT_EQ(200, out_height_); 418 EXPECT_EQ(200, out_height_);
420 419
421 // Request resolution of 3 / 8. Expect adapt down. 420 // Request resolution of 3 / 8. Expect adapt down.
422 format.width = 640 * 3 / 8; 421 format.width = 640 * 3 / 8;
423 format.height = 400 * 3 / 8; 422 format.height = 400 * 3 / 8;
424 adapter_.OnOutputFormatRequest(format); 423 adapter_.OnOutputFormatRequest(format);
425 adapter_.AdaptFrameResolution(640, 400, 424 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
426 &cropped_width_, &cropped_height_, 425 &cropped_width_, &cropped_height_,
427 &out_width_, &out_height_); 426 &out_width_, &out_height_));
428 EXPECT_EQ(640, cropped_width_); 427 EXPECT_EQ(640, cropped_width_);
429 EXPECT_EQ(400, cropped_height_); 428 EXPECT_EQ(400, cropped_height_);
430 EXPECT_EQ(640 * 3 / 8, out_width_); 429 EXPECT_EQ(640 * 3 / 8, out_width_);
431 EXPECT_EQ(400 * 3 / 8, out_height_); 430 EXPECT_EQ(400 * 3 / 8, out_height_);
432 431
433 // Switch back up. Expect adapt. 432 // Switch back up. Expect adapt.
434 format.width = 320; 433 format.width = 320;
435 format.height = 200; 434 format.height = 200;
436 adapter_.OnOutputFormatRequest(format); 435 adapter_.OnOutputFormatRequest(format);
437 adapter_.AdaptFrameResolution(640, 400, 436 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
438 &cropped_width_, &cropped_height_, 437 &cropped_width_, &cropped_height_,
439 &out_width_, &out_height_); 438 &out_width_, &out_height_));
440 EXPECT_EQ(640, cropped_width_); 439 EXPECT_EQ(640, cropped_width_);
441 EXPECT_EQ(400, cropped_height_); 440 EXPECT_EQ(400, cropped_height_);
442 EXPECT_EQ(320, out_width_); 441 EXPECT_EQ(320, out_width_);
443 EXPECT_EQ(200, out_height_); 442 EXPECT_EQ(200, out_height_);
444 443
445 // Format request 480x300. 444 // Format request 480x300.
446 format.width = 480; 445 format.width = 480;
447 format.height = 300; 446 format.height = 300;
448 adapter_.OnOutputFormatRequest(format); 447 adapter_.OnOutputFormatRequest(format);
449 adapter_.AdaptFrameResolution(640, 400, 448 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400,
450 &cropped_width_, &cropped_height_, 449 &cropped_width_, &cropped_height_,
451 &out_width_, &out_height_); 450 &out_width_, &out_height_));
452 EXPECT_EQ(640, cropped_width_); 451 EXPECT_EQ(640, cropped_width_);
453 EXPECT_EQ(400, cropped_height_); 452 EXPECT_EQ(400, cropped_height_);
454 EXPECT_EQ(480, out_width_); 453 EXPECT_EQ(480, out_width_);
455 EXPECT_EQ(300, out_height_); 454 EXPECT_EQ(300, out_height_);
456 } 455 }
457 456
458 TEST_F(VideoAdapterTest, TestViewRequestPlusCameraSwitch) { 457 TEST_F(VideoAdapterTest, TestViewRequestPlusCameraSwitch) {
459 // Start at HD. 458 // Start at HD.
460 VideoFormat format(1280, 720, VideoFormat::FpsToInterval(30), 0); 459 VideoFormat format(1280, 720, VideoFormat::FpsToInterval(30), 0);
461 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 460 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
462 adapter_.AdaptFrameResolution(1280, 720, 461 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
463 &cropped_width_, &cropped_height_, 462 &cropped_width_, &cropped_height_,
464 &out_width_, &out_height_); 463 &out_width_, &out_height_));
465 EXPECT_EQ(1280, cropped_width_); 464 EXPECT_EQ(1280, cropped_width_);
466 EXPECT_EQ(720, cropped_height_); 465 EXPECT_EQ(720, cropped_height_);
467 EXPECT_EQ(1280, out_width_); 466 EXPECT_EQ(1280, out_width_);
468 EXPECT_EQ(720, out_height_); 467 EXPECT_EQ(720, out_height_);
469 468
470 // Format request for VGA. 469 // Format request for VGA.
471 format.width = 640; 470 format.width = 640;
472 format.height = 360; 471 format.height = 360;
473 adapter_.OnOutputFormatRequest(format); 472 adapter_.OnOutputFormatRequest(format);
474 adapter_.AdaptFrameResolution(1280, 720, 473 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
475 &cropped_width_, &cropped_height_, 474 &cropped_width_, &cropped_height_,
476 &out_width_, &out_height_); 475 &out_width_, &out_height_));
477 EXPECT_EQ(1280, cropped_width_); 476 EXPECT_EQ(1280, cropped_width_);
478 EXPECT_EQ(720, cropped_height_); 477 EXPECT_EQ(720, cropped_height_);
479 EXPECT_EQ(640, out_width_); 478 EXPECT_EQ(640, out_width_);
480 EXPECT_EQ(360, out_height_); 479 EXPECT_EQ(360, out_height_);
481 480
482 // Now, the camera reopens at VGA. 481 // Now, the camera reopens at VGA.
483 // Both the frame and the output format should be 640x360. 482 // Both the frame and the output format should be 640x360.
484 adapter_.AdaptFrameResolution(640, 360, 483 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 360,
485 &cropped_width_, &cropped_height_, 484 &cropped_width_, &cropped_height_,
486 &out_width_, &out_height_); 485 &out_width_, &out_height_));
487 EXPECT_EQ(640, cropped_width_); 486 EXPECT_EQ(640, cropped_width_);
488 EXPECT_EQ(360, cropped_height_); 487 EXPECT_EQ(360, cropped_height_);
489 EXPECT_EQ(640, out_width_); 488 EXPECT_EQ(640, out_width_);
490 EXPECT_EQ(360, out_height_); 489 EXPECT_EQ(360, out_height_);
491 490
492 // And another view request comes in for 640x360, which should have no 491 // And another view request comes in for 640x360, which should have no
493 // real impact. 492 // real impact.
494 adapter_.OnOutputFormatRequest(format); 493 adapter_.OnOutputFormatRequest(format);
495 adapter_.AdaptFrameResolution(640, 360, 494 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 360,
496 &cropped_width_, &cropped_height_, 495 &cropped_width_, &cropped_height_,
497 &out_width_, &out_height_); 496 &out_width_, &out_height_));
498 EXPECT_EQ(640, cropped_width_); 497 EXPECT_EQ(640, cropped_width_);
499 EXPECT_EQ(360, cropped_height_); 498 EXPECT_EQ(360, cropped_height_);
500 EXPECT_EQ(640, out_width_); 499 EXPECT_EQ(640, out_width_);
501 EXPECT_EQ(360, out_height_); 500 EXPECT_EQ(360, out_height_);
502 } 501 }
503 502
504 TEST_F(VideoAdapterTest, TestVGAWidth) { 503 TEST_F(VideoAdapterTest, TestVGAWidth) {
505 // Reqeuested Output format is 640x360. 504 // Reqeuested Output format is 640x360.
506 VideoFormat format(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420); 505 VideoFormat format(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420);
507 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 506 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
508 adapter_.OnOutputFormatRequest(format); 507 adapter_.OnOutputFormatRequest(format);
509 508
510 adapter_.AdaptFrameResolution(640, 480, 509 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
511 &cropped_width_, &cropped_height_, 510 &cropped_width_, &cropped_height_,
512 &out_width_, &out_height_); 511 &out_width_, &out_height_));
513 // Expect cropping. 512 // Expect cropping.
514 EXPECT_EQ(640, cropped_width_); 513 EXPECT_EQ(640, cropped_width_);
515 EXPECT_EQ(360, cropped_height_); 514 EXPECT_EQ(360, cropped_height_);
516 EXPECT_EQ(640, out_width_); 515 EXPECT_EQ(640, out_width_);
517 EXPECT_EQ(360, out_height_); 516 EXPECT_EQ(360, out_height_);
518 517
519 // But if frames come in at 640x360, we shouldn't adapt them down. 518 // But if frames come in at 640x360, we shouldn't adapt them down.
520 adapter_.AdaptFrameResolution(640, 360, 519 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 360,
521 &cropped_width_, &cropped_height_, 520 &cropped_width_, &cropped_height_,
522 &out_width_, &out_height_); 521 &out_width_, &out_height_));
523 EXPECT_EQ(640, cropped_width_); 522 EXPECT_EQ(640, cropped_width_);
524 EXPECT_EQ(360, cropped_height_); 523 EXPECT_EQ(360, cropped_height_);
525 EXPECT_EQ(640, out_width_); 524 EXPECT_EQ(640, out_width_);
526 EXPECT_EQ(360, out_height_); 525 EXPECT_EQ(360, out_height_);
527 526
528 adapter_.AdaptFrameResolution(640, 480, 527 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
529 &cropped_width_, &cropped_height_, 528 &cropped_width_, &cropped_height_,
530 &out_width_, &out_height_); 529 &out_width_, &out_height_));
531 EXPECT_EQ(640, cropped_width_); 530 EXPECT_EQ(640, cropped_width_);
532 EXPECT_EQ(360, cropped_height_); 531 EXPECT_EQ(360, cropped_height_);
533 EXPECT_EQ(640, out_width_); 532 EXPECT_EQ(640, out_width_);
534 EXPECT_EQ(360, out_height_); 533 EXPECT_EQ(360, out_height_);
535 } 534 }
536 535
537 TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) { 536 TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
538 adapter_.AdaptFrameResolution(1280, 720, 537 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
539 &cropped_width_, &cropped_height_, 538 &cropped_width_, &cropped_height_,
540 &out_width_, &out_height_); 539 &out_width_, &out_height_));
541 EXPECT_EQ(1280, cropped_width_); 540 EXPECT_EQ(1280, cropped_width_);
542 EXPECT_EQ(720, cropped_height_); 541 EXPECT_EQ(720, cropped_height_);
543 EXPECT_EQ(1280, out_width_); 542 EXPECT_EQ(1280, out_width_);
544 EXPECT_EQ(720, out_height_); 543 EXPECT_EQ(720, out_height_);
545 544
546 // Adapt down one step. 545 // Adapt down one step.
547 adapter_.OnResolutionRequest(rtc::Optional<int>(1280 * 720 - 1), 546 adapter_.OnResolutionRequest(rtc::Optional<int>(1280 * 720 - 1),
548 rtc::Optional<int>()); 547 rtc::Optional<int>());
549 adapter_.AdaptFrameResolution(1280, 720, 548 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
550 &cropped_width_, &cropped_height_, 549 &cropped_width_, &cropped_height_,
551 &out_width_, &out_height_); 550 &out_width_, &out_height_));
552 EXPECT_EQ(1280, cropped_width_); 551 EXPECT_EQ(1280, cropped_width_);
553 EXPECT_EQ(720, cropped_height_); 552 EXPECT_EQ(720, cropped_height_);
554 EXPECT_EQ(960, out_width_); 553 EXPECT_EQ(960, out_width_);
555 EXPECT_EQ(540, out_height_); 554 EXPECT_EQ(540, out_height_);
556 555
557 // Adapt down one step more. 556 // Adapt down one step more.
558 adapter_.OnResolutionRequest(rtc::Optional<int>(960 * 540 - 1), 557 adapter_.OnResolutionRequest(rtc::Optional<int>(960 * 540 - 1),
559 rtc::Optional<int>()); 558 rtc::Optional<int>());
560 adapter_.AdaptFrameResolution(1280, 720, 559 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
561 &cropped_width_, &cropped_height_, 560 &cropped_width_, &cropped_height_,
562 &out_width_, &out_height_); 561 &out_width_, &out_height_));
563 EXPECT_EQ(1280, cropped_width_); 562 EXPECT_EQ(1280, cropped_width_);
564 EXPECT_EQ(720, cropped_height_); 563 EXPECT_EQ(720, cropped_height_);
565 EXPECT_EQ(640, out_width_); 564 EXPECT_EQ(640, out_width_);
566 EXPECT_EQ(360, out_height_); 565 EXPECT_EQ(360, out_height_);
567 566
568 // Adapt down one step more. 567 // Adapt down one step more.
569 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1), 568 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
570 rtc::Optional<int>()); 569 rtc::Optional<int>());
571 adapter_.AdaptFrameResolution(1280, 720, 570 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
572 &cropped_width_, &cropped_height_, 571 &cropped_width_, &cropped_height_,
573 &out_width_, &out_height_); 572 &out_width_, &out_height_));
574 EXPECT_EQ(1280, cropped_width_); 573 EXPECT_EQ(1280, cropped_width_);
575 EXPECT_EQ(720, cropped_height_); 574 EXPECT_EQ(720, cropped_height_);
576 EXPECT_EQ(480, out_width_); 575 EXPECT_EQ(480, out_width_);
577 EXPECT_EQ(270, out_height_); 576 EXPECT_EQ(270, out_height_);
578 577
579 // Adapt up one step. 578 // Adapt up one step.
580 adapter_.OnResolutionRequest(rtc::Optional<int>(), 579 adapter_.OnResolutionRequest(rtc::Optional<int>(),
581 rtc::Optional<int>(480 * 270)); 580 rtc::Optional<int>(480 * 270));
582 adapter_.AdaptFrameResolution(1280, 720, 581 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
583 &cropped_width_, &cropped_height_, 582 &cropped_width_, &cropped_height_,
584 &out_width_, &out_height_); 583 &out_width_, &out_height_));
585 EXPECT_EQ(1280, cropped_width_); 584 EXPECT_EQ(1280, cropped_width_);
586 EXPECT_EQ(720, cropped_height_); 585 EXPECT_EQ(720, cropped_height_);
587 EXPECT_EQ(640, out_width_); 586 EXPECT_EQ(640, out_width_);
588 EXPECT_EQ(360, out_height_); 587 EXPECT_EQ(360, out_height_);
589 588
590 // Adapt up one step more. 589 // Adapt up one step more.
591 adapter_.OnResolutionRequest(rtc::Optional<int>(), 590 adapter_.OnResolutionRequest(rtc::Optional<int>(),
592 rtc::Optional<int>(640 * 360)); 591 rtc::Optional<int>(640 * 360));
593 adapter_.AdaptFrameResolution(1280, 720, 592 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
594 &cropped_width_, &cropped_height_, 593 &cropped_width_, &cropped_height_,
595 &out_width_, &out_height_); 594 &out_width_, &out_height_));
596 EXPECT_EQ(1280, cropped_width_); 595 EXPECT_EQ(1280, cropped_width_);
597 EXPECT_EQ(720, cropped_height_); 596 EXPECT_EQ(720, cropped_height_);
598 EXPECT_EQ(960, out_width_); 597 EXPECT_EQ(960, out_width_);
599 EXPECT_EQ(540, out_height_); 598 EXPECT_EQ(540, out_height_);
600 599
601 // Adapt up one step more. 600 // Adapt up one step more.
602 adapter_.OnResolutionRequest(rtc::Optional<int>(), 601 adapter_.OnResolutionRequest(rtc::Optional<int>(),
603 rtc::Optional<int>(960 * 720)); 602 rtc::Optional<int>(960 * 720));
604 adapter_.AdaptFrameResolution(1280, 720, 603 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
605 &cropped_width_, &cropped_height_, 604 &cropped_width_, &cropped_height_,
606 &out_width_, &out_height_); 605 &out_width_, &out_height_));
607 EXPECT_EQ(1280, cropped_width_); 606 EXPECT_EQ(1280, cropped_width_);
608 EXPECT_EQ(720, cropped_height_); 607 EXPECT_EQ(720, cropped_height_);
609 EXPECT_EQ(1280, out_width_); 608 EXPECT_EQ(1280, out_width_);
610 EXPECT_EQ(720, out_height_); 609 EXPECT_EQ(720, out_height_);
611 } 610 }
612 611
613 TEST_F(VideoAdapterTest, TestOnResolutionRequestMaxZero) { 612 TEST_F(VideoAdapterTest, TestOnResolutionRequestMaxZero) {
614 adapter_.AdaptFrameResolution(1280, 720, 613 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
615 &cropped_width_, &cropped_height_, 614 &cropped_width_, &cropped_height_,
616 &out_width_, &out_height_); 615 &out_width_, &out_height_));
617 EXPECT_EQ(1280, cropped_width_); 616 EXPECT_EQ(1280, cropped_width_);
618 EXPECT_EQ(720, cropped_height_); 617 EXPECT_EQ(720, cropped_height_);
619 EXPECT_EQ(1280, out_width_); 618 EXPECT_EQ(1280, out_width_);
620 EXPECT_EQ(720, out_height_); 619 EXPECT_EQ(720, out_height_);
621 620
622 adapter_.OnResolutionRequest(rtc::Optional<int>(0), rtc::Optional<int>()); 621 adapter_.OnResolutionRequest(rtc::Optional<int>(0), rtc::Optional<int>());
623 adapter_.AdaptFrameResolution(1280, 720, 622 EXPECT_FALSE(adapter_.AdaptFrameResolution(1280, 720,
624 &cropped_width_, &cropped_height_, 623 &cropped_width_, &cropped_height_,
625 &out_width_, &out_height_); 624 &out_width_, &out_height_));
626 EXPECT_EQ(0, out_width_);
627 EXPECT_EQ(0, out_height_);
628 } 625 }
629 626
630 TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) { 627 TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
631 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1), 628 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
632 rtc::Optional<int>()); 629 rtc::Optional<int>());
633 adapter_.AdaptFrameResolution(1280, 720, 630 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
634 &cropped_width_, &cropped_height_, 631 &cropped_width_, &cropped_height_,
635 &out_width_, &out_height_); 632 &out_width_, &out_height_));
636 EXPECT_EQ(1280, cropped_width_); 633 EXPECT_EQ(1280, cropped_width_);
637 EXPECT_EQ(720, cropped_height_); 634 EXPECT_EQ(720, cropped_height_);
638 EXPECT_EQ(480, out_width_); 635 EXPECT_EQ(480, out_width_);
639 EXPECT_EQ(270, out_height_); 636 EXPECT_EQ(270, out_height_);
640 637
641 adapter_.OnResolutionRequest(rtc::Optional<int>(), 638 adapter_.OnResolutionRequest(rtc::Optional<int>(),
642 rtc::Optional<int>(960 * 720)); 639 rtc::Optional<int>(960 * 720));
643 adapter_.AdaptFrameResolution(1280, 720, 640 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
644 &cropped_width_, &cropped_height_, 641 &cropped_width_, &cropped_height_,
645 &out_width_, &out_height_); 642 &out_width_, &out_height_));
646 EXPECT_EQ(1280, cropped_width_); 643 EXPECT_EQ(1280, cropped_width_);
647 EXPECT_EQ(720, cropped_height_); 644 EXPECT_EQ(720, cropped_height_);
648 EXPECT_EQ(1280, out_width_); 645 EXPECT_EQ(1280, out_width_);
649 EXPECT_EQ(720, out_height_); 646 EXPECT_EQ(720, out_height_);
650 } 647 }
651 648
652 TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) { 649 TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) {
653 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1), 650 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
654 rtc::Optional<int>()); 651 rtc::Optional<int>());
655 adapter_.AdaptFrameResolution(1280, 720, 652 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
656 &cropped_width_, &cropped_height_, 653 &cropped_width_, &cropped_height_,
657 &out_width_, &out_height_); 654 &out_width_, &out_height_));
658 EXPECT_EQ(1280, cropped_width_); 655 EXPECT_EQ(1280, cropped_width_);
659 EXPECT_EQ(720, cropped_height_); 656 EXPECT_EQ(720, cropped_height_);
660 EXPECT_EQ(480, out_width_); 657 EXPECT_EQ(480, out_width_);
661 EXPECT_EQ(270, out_height_); 658 EXPECT_EQ(270, out_height_);
662 659
663 VideoFormat new_format(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420); 660 VideoFormat new_format(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420);
664 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 661 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
665 adapter_.OnOutputFormatRequest(new_format); 662 adapter_.OnOutputFormatRequest(new_format);
666 adapter_.AdaptFrameResolution(1280, 720, 663 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
667 &cropped_width_, &cropped_height_, 664 &cropped_width_, &cropped_height_,
668 &out_width_, &out_height_); 665 &out_width_, &out_height_));
669 EXPECT_EQ(1280, cropped_width_); 666 EXPECT_EQ(1280, cropped_width_);
670 EXPECT_EQ(720, cropped_height_); 667 EXPECT_EQ(720, cropped_height_);
671 EXPECT_EQ(480, out_width_); 668 EXPECT_EQ(480, out_width_);
672 EXPECT_EQ(270, out_height_); 669 EXPECT_EQ(270, out_height_);
673 670
674 adapter_.OnResolutionRequest(rtc::Optional<int>(), 671 adapter_.OnResolutionRequest(rtc::Optional<int>(),
675 rtc::Optional<int>(960 * 720)); 672 rtc::Optional<int>(960 * 720));
676 adapter_.AdaptFrameResolution(1280, 720, 673 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
677 &cropped_width_, &cropped_height_, 674 &cropped_width_, &cropped_height_,
678 &out_width_, &out_height_); 675 &out_width_, &out_height_));
679 EXPECT_EQ(1280, cropped_width_); 676 EXPECT_EQ(1280, cropped_width_);
680 EXPECT_EQ(720, cropped_height_); 677 EXPECT_EQ(720, cropped_height_);
681 EXPECT_EQ(640, out_width_); 678 EXPECT_EQ(640, out_width_);
682 EXPECT_EQ(360, out_height_); 679 EXPECT_EQ(360, out_height_);
683 } 680 }
684 681
685 TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) { 682 TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) {
686 adapter_.AdaptFrameResolution(1280, 720, 683 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
687 &cropped_width_, &cropped_height_, 684 &cropped_width_, &cropped_height_,
688 &out_width_, &out_height_); 685 &out_width_, &out_height_));
689 EXPECT_EQ(1280, cropped_width_); 686 EXPECT_EQ(1280, cropped_width_);
690 EXPECT_EQ(720, cropped_height_); 687 EXPECT_EQ(720, cropped_height_);
691 EXPECT_EQ(1280, out_width_); 688 EXPECT_EQ(1280, out_width_);
692 EXPECT_EQ(720, out_height_); 689 EXPECT_EQ(720, out_height_);
693 690
694 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1), 691 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
695 rtc::Optional<int>()); 692 rtc::Optional<int>());
696 adapter_.AdaptFrameResolution(1280, 720, 693 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
697 &cropped_width_, &cropped_height_, 694 &cropped_width_, &cropped_height_,
698 &out_width_, &out_height_); 695 &out_width_, &out_height_));
699 EXPECT_EQ(1280, cropped_width_); 696 EXPECT_EQ(1280, cropped_width_);
700 EXPECT_EQ(720, cropped_height_); 697 EXPECT_EQ(720, cropped_height_);
701 EXPECT_EQ(480, out_width_); 698 EXPECT_EQ(480, out_width_);
702 EXPECT_EQ(270, out_height_); 699 EXPECT_EQ(270, out_height_);
703 700
704 adapter_.OnResolutionRequest(rtc::Optional<int>(), rtc::Optional<int>()); 701 adapter_.OnResolutionRequest(rtc::Optional<int>(), rtc::Optional<int>());
705 adapter_.AdaptFrameResolution(1280, 720, 702 EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720,
706 &cropped_width_, &cropped_height_, 703 &cropped_width_, &cropped_height_,
707 &out_width_, &out_height_); 704 &out_width_, &out_height_));
708 EXPECT_EQ(1280, cropped_width_); 705 EXPECT_EQ(1280, cropped_width_);
709 EXPECT_EQ(720, cropped_height_); 706 EXPECT_EQ(720, cropped_height_);
710 EXPECT_EQ(1280, out_width_); 707 EXPECT_EQ(1280, out_width_);
711 EXPECT_EQ(720, out_height_); 708 EXPECT_EQ(720, out_height_);
712 } 709 }
713 710
714 TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) { 711 TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
715 // Ask for 640x360 (16:9 aspect). 712 // Ask for 640x360 (16:9 aspect).
716 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 713 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
717 adapter_.OnOutputFormatRequest( 714 adapter_.OnOutputFormatRequest(
718 VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420)); 715 VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420));
719 // Send 640x480 (4:3 aspect). 716 // Send 640x480 (4:3 aspect).
720 adapter_.AdaptFrameResolution(640, 480, 717 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
721 &cropped_width_, &cropped_height_, 718 &cropped_width_, &cropped_height_,
722 &out_width_, &out_height_); 719 &out_width_, &out_height_));
723 // Expect cropping to 16:9 format and no scaling. 720 // Expect cropping to 16:9 format and no scaling.
724 EXPECT_EQ(640, cropped_width_); 721 EXPECT_EQ(640, cropped_width_);
725 EXPECT_EQ(360, cropped_height_); 722 EXPECT_EQ(360, cropped_height_);
726 EXPECT_EQ(640, out_width_); 723 EXPECT_EQ(640, out_width_);
727 EXPECT_EQ(360, out_height_); 724 EXPECT_EQ(360, out_height_);
728 725
729 // Adapt down one step. 726 // Adapt down one step.
730 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1), 727 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
731 rtc::Optional<int>()); 728 rtc::Optional<int>());
732 // Expect cropping to 16:9 format and 3/4 scaling. 729 // Expect cropping to 16:9 format and 3/4 scaling.
733 adapter_.AdaptFrameResolution(640, 480, 730 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
734 &cropped_width_, &cropped_height_, 731 &cropped_width_, &cropped_height_,
735 &out_width_, &out_height_); 732 &out_width_, &out_height_));
736 EXPECT_EQ(640, cropped_width_); 733 EXPECT_EQ(640, cropped_width_);
737 EXPECT_EQ(360, cropped_height_); 734 EXPECT_EQ(360, cropped_height_);
738 EXPECT_EQ(480, out_width_); 735 EXPECT_EQ(480, out_width_);
739 EXPECT_EQ(270, out_height_); 736 EXPECT_EQ(270, out_height_);
740 737
741 // Adapt down one step more. 738 // Adapt down one step more.
742 adapter_.OnResolutionRequest(rtc::Optional<int>(480 * 270 - 1), 739 adapter_.OnResolutionRequest(rtc::Optional<int>(480 * 270 - 1),
743 rtc::Optional<int>()); 740 rtc::Optional<int>());
744 // Expect cropping to 16:9 format and 1/2 scaling. 741 // Expect cropping to 16:9 format and 1/2 scaling.
745 adapter_.AdaptFrameResolution(640, 480, 742 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
746 &cropped_width_, &cropped_height_, 743 &cropped_width_, &cropped_height_,
747 &out_width_, &out_height_); 744 &out_width_, &out_height_));
748 EXPECT_EQ(640, cropped_width_); 745 EXPECT_EQ(640, cropped_width_);
749 EXPECT_EQ(360, cropped_height_); 746 EXPECT_EQ(360, cropped_height_);
750 EXPECT_EQ(320, out_width_); 747 EXPECT_EQ(320, out_width_);
751 EXPECT_EQ(180, out_height_); 748 EXPECT_EQ(180, out_height_);
752 749
753 // Adapt up one step. 750 // Adapt up one step.
754 adapter_.OnResolutionRequest(rtc::Optional<int>(), 751 adapter_.OnResolutionRequest(rtc::Optional<int>(),
755 rtc::Optional<int>(320 * 180)); 752 rtc::Optional<int>(320 * 180));
756 // Expect cropping to 16:9 format and 3/4 scaling. 753 // Expect cropping to 16:9 format and 3/4 scaling.
757 adapter_.AdaptFrameResolution(640, 480, 754 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
758 &cropped_width_, &cropped_height_, 755 &cropped_width_, &cropped_height_,
759 &out_width_, &out_height_); 756 &out_width_, &out_height_));
760 EXPECT_EQ(640, cropped_width_); 757 EXPECT_EQ(640, cropped_width_);
761 EXPECT_EQ(360, cropped_height_); 758 EXPECT_EQ(360, cropped_height_);
762 EXPECT_EQ(480, out_width_); 759 EXPECT_EQ(480, out_width_);
763 EXPECT_EQ(270, out_height_); 760 EXPECT_EQ(270, out_height_);
764 761
765 // Adapt up one step more. 762 // Adapt up one step more.
766 adapter_.OnResolutionRequest(rtc::Optional<int>(), 763 adapter_.OnResolutionRequest(rtc::Optional<int>(),
767 rtc::Optional<int>(480 * 270)); 764 rtc::Optional<int>(480 * 270));
768 // Expect cropping to 16:9 format and no scaling. 765 // Expect cropping to 16:9 format and no scaling.
769 adapter_.AdaptFrameResolution(640, 480, 766 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
770 &cropped_width_, &cropped_height_, 767 &cropped_width_, &cropped_height_,
771 &out_width_, &out_height_); 768 &out_width_, &out_height_));
772 EXPECT_EQ(640, cropped_width_); 769 EXPECT_EQ(640, cropped_width_);
773 EXPECT_EQ(360, cropped_height_); 770 EXPECT_EQ(360, cropped_height_);
774 EXPECT_EQ(640, out_width_); 771 EXPECT_EQ(640, out_width_);
775 EXPECT_EQ(360, out_height_); 772 EXPECT_EQ(360, out_height_);
776 773
777 // Try to adapt up one step more. 774 // Try to adapt up one step more.
778 adapter_.OnResolutionRequest(rtc::Optional<int>(), 775 adapter_.OnResolutionRequest(rtc::Optional<int>(),
779 rtc::Optional<int>(640 * 360)); 776 rtc::Optional<int>(640 * 360));
780 // Expect cropping to 16:9 format and no scaling. 777 // Expect cropping to 16:9 format and no scaling.
781 adapter_.AdaptFrameResolution(640, 480, 778 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
782 &cropped_width_, &cropped_height_, 779 &cropped_width_, &cropped_height_,
783 &out_width_, &out_height_); 780 &out_width_, &out_height_));
784 EXPECT_EQ(640, cropped_width_); 781 EXPECT_EQ(640, cropped_width_);
785 EXPECT_EQ(360, cropped_height_); 782 EXPECT_EQ(360, cropped_height_);
786 EXPECT_EQ(640, out_width_); 783 EXPECT_EQ(640, out_width_);
787 EXPECT_EQ(360, out_height_); 784 EXPECT_EQ(360, out_height_);
788 } 785 }
789 786
790 TEST_F(VideoAdapterTest, TestCroppingOddResolution) { 787 TEST_F(VideoAdapterTest, TestCroppingOddResolution) {
791 // Ask for 640x360 (16:9 aspect), with 3/16 scaling. 788 // Ask for 640x360 (16:9 aspect), with 3/16 scaling.
792 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30)); 789 adapter_.SetExpectedInputFrameInterval(VideoFormat::FpsToInterval(30));
793 adapter_.OnOutputFormatRequest( 790 adapter_.OnOutputFormatRequest(
794 VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420)); 791 VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_I420));
795 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 * 3 / 16 * 3 / 16), 792 adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 * 3 / 16 * 3 / 16),
796 rtc::Optional<int>()); 793 rtc::Optional<int>());
797 794
798 // Send 640x480 (4:3 aspect). 795 // Send 640x480 (4:3 aspect).
799 adapter_.AdaptFrameResolution(640, 480, 796 EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480,
800 &cropped_width_, &cropped_height_, 797 &cropped_width_, &cropped_height_,
801 &out_width_, &out_height_); 798 &out_width_, &out_height_));
802 799
803 // Instead of getting the exact aspect ratio with cropped resolution 640x360, 800 // Instead of getting the exact aspect ratio with cropped resolution 640x360,
804 // the resolution should be adjusted to get a perfect scale factor instead. 801 // the resolution should be adjusted to get a perfect scale factor instead.
805 EXPECT_EQ(640, cropped_width_); 802 EXPECT_EQ(640, cropped_width_);
806 EXPECT_EQ(368, cropped_height_); 803 EXPECT_EQ(368, cropped_height_);
807 EXPECT_EQ(120, out_width_); 804 EXPECT_EQ(120, out_width_);
808 EXPECT_EQ(69, out_height_); 805 EXPECT_EQ(69, out_height_);
809 } 806 }
810 807
811 } // namespace cricket 808 } // namespace cricket
OLDNEW
« webrtc/common_video/video_frame_buffer.cc ('K') | « webrtc/media/base/videoadapter.cc ('k') | webrtc/media/base/videocapturer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698