1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
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
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <stdio.h>
12
13 #include <map>
14 #include <sstream>
15
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "webrtc/base/scoped_ptr.h"
18 #include "webrtc/base/scoped_ref_ptr.h"
19 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
20 #include "webrtc/modules/utility/include/process_thread.h"
21 #include "webrtc/modules/video_capture/video_capture.h"
22 #include "webrtc/modules/video_capture/video_capture_factory.h"
23 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
24 #include "webrtc/system_wrappers/include/sleep.h"
25 #include "webrtc/system_wrappers/include/tick_util.h"
26 #include "webrtc/video_frame.h"
27
28 using rtc::scoped_ptr;
29 using webrtc::CriticalSectionWrapper;
30 using webrtc::CriticalSectionScoped;
31 using webrtc::SleepMs;
32 using webrtc::TickTime;
33 using webrtc::VideoCaptureAlarm;
34 using webrtc::VideoCaptureCapability;
35 using webrtc::VideoCaptureDataCallback;
36 using webrtc::VideoCaptureFactory;
37 using webrtc::VideoCaptureFeedBack;
38 using webrtc::VideoCaptureModule;
39
40
41 #define WAIT_(ex, timeout, res) \
42 do { \
43 res = (ex); \
44 int64_t start = TickTime::MillisecondTimestamp(); \
45 while (!res && TickTime::MillisecondTimestamp() < start + timeout) { \
46 SleepMs(5); \
47 res = (ex); \
48 } \
49 } while (0)
50
51 #define EXPECT_TRUE_WAIT(ex, timeout) \
52 do { \
53 bool res; \
54 WAIT_(ex, timeout, res); \
55 if (!res) EXPECT_TRUE(ex); \
56 } while (0)
57
58
59 static const int kTimeOut = 5000;
60 static const int kTestHeight = 288;
61 static const int kTestWidth = 352;
62 static const int kTestFramerate = 30;
63
64 // Compares the content of two video frames.
CompareFrames(const webrtc::VideoFrame & frame1,const webrtc::VideoFrame & frame2)65 static bool CompareFrames(const webrtc::VideoFrame& frame1,
66 const webrtc::VideoFrame& frame2) {
67 bool result =
68 (frame1.stride(webrtc::kYPlane) == frame2.stride(webrtc::kYPlane)) &&
69 (frame1.stride(webrtc::kUPlane) == frame2.stride(webrtc::kUPlane)) &&
70 (frame1.stride(webrtc::kVPlane) == frame2.stride(webrtc::kVPlane)) &&
71 (frame1.width() == frame2.width()) &&
72 (frame1.height() == frame2.height());
73
74 if (!result)
75 return false;
76 for (int plane = 0; plane < webrtc::kNumOfPlanes; plane ++) {
77 webrtc::PlaneType plane_type = static_cast<webrtc::PlaneType>(plane);
78 int allocated_size1 = frame1.allocated_size(plane_type);
79 int allocated_size2 = frame2.allocated_size(plane_type);
80 if (allocated_size1 != allocated_size2)
81 return false;
82 const uint8_t* plane_buffer1 = frame1.buffer(plane_type);
83 const uint8_t* plane_buffer2 = frame2.buffer(plane_type);
84 if (memcmp(plane_buffer1, plane_buffer2, allocated_size1))
85 return false;
86 }
87 return true;
88 }
89
90 class TestVideoCaptureCallback : public VideoCaptureDataCallback {
91 public:
TestVideoCaptureCallback()92 TestVideoCaptureCallback()
93 : capture_cs_(CriticalSectionWrapper::CreateCriticalSection()),
94 capture_delay_(-1),
95 last_render_time_ms_(0),
96 incoming_frames_(0),
97 timing_warnings_(0),
98 rotate_frame_(webrtc::kVideoRotation_0) {}
99
~TestVideoCaptureCallback()100 ~TestVideoCaptureCallback() {
101 if (timing_warnings_ > 0)
102 printf("No of timing warnings %d\n", timing_warnings_);
103 }
104
OnIncomingCapturedFrame(const int32_t id,const webrtc::VideoFrame & videoFrame)105 virtual void OnIncomingCapturedFrame(const int32_t id,
106 const webrtc::VideoFrame& videoFrame) {
107 CriticalSectionScoped cs(capture_cs_.get());
108 int height = videoFrame.height();
109 int width = videoFrame.width();
110 #if ANDROID
111 // Android camera frames may be rotated depending on test device
112 // orientation.
113 EXPECT_TRUE(height == capability_.height || height == capability_.width);
114 EXPECT_TRUE(width == capability_.width || width == capability_.height);
115 #else
116 if (rotate_frame_ == webrtc::kVideoRotation_90 ||
117 rotate_frame_ == webrtc::kVideoRotation_270) {
118 EXPECT_EQ(width, capability_.height);
119 EXPECT_EQ(height, capability_.width);
120 } else {
121 EXPECT_EQ(height, capability_.height);
122 EXPECT_EQ(width, capability_.width);
123 }
124 #endif
125 // RenderTimstamp should be the time now.
126 EXPECT_TRUE(
127 videoFrame.render_time_ms() >= TickTime::MillisecondTimestamp()-30 &&
128 videoFrame.render_time_ms() <= TickTime::MillisecondTimestamp());
129
130 if ((videoFrame.render_time_ms() >
131 last_render_time_ms_ + (1000 * 1.1) / capability_.maxFPS &&
132 last_render_time_ms_ > 0) ||
133 (videoFrame.render_time_ms() <
134 last_render_time_ms_ + (1000 * 0.9) / capability_.maxFPS &&
135 last_render_time_ms_ > 0)) {
136 timing_warnings_++;
137 }
138
139 incoming_frames_++;
140 last_render_time_ms_ = videoFrame.render_time_ms();
141 last_frame_.CopyFrame(videoFrame);
142 }
143
OnCaptureDelayChanged(const int32_t id,const int32_t delay)144 virtual void OnCaptureDelayChanged(const int32_t id,
145 const int32_t delay) {
146 CriticalSectionScoped cs(capture_cs_.get());
147 capture_delay_ = delay;
148 }
149
SetExpectedCapability(VideoCaptureCapability capability)150 void SetExpectedCapability(VideoCaptureCapability capability) {
151 CriticalSectionScoped cs(capture_cs_.get());
152 capability_= capability;
153 incoming_frames_ = 0;
154 last_render_time_ms_ = 0;
155 capture_delay_ = -1;
156 }
incoming_frames()157 int incoming_frames() {
158 CriticalSectionScoped cs(capture_cs_.get());
159 return incoming_frames_;
160 }
161
capture_delay()162 int capture_delay() {
163 CriticalSectionScoped cs(capture_cs_.get());
164 return capture_delay_;
165 }
timing_warnings()166 int timing_warnings() {
167 CriticalSectionScoped cs(capture_cs_.get());
168 return timing_warnings_;
169 }
capability()170 VideoCaptureCapability capability() {
171 CriticalSectionScoped cs(capture_cs_.get());
172 return capability_;
173 }
174
CompareLastFrame(const webrtc::VideoFrame & frame)175 bool CompareLastFrame(const webrtc::VideoFrame& frame) {
176 CriticalSectionScoped cs(capture_cs_.get());
177 return CompareFrames(last_frame_, frame);
178 }
179
SetExpectedCaptureRotation(webrtc::VideoRotation rotation)180 void SetExpectedCaptureRotation(webrtc::VideoRotation rotation) {
181 CriticalSectionScoped cs(capture_cs_.get());
182 rotate_frame_ = rotation;
183 }
184
185 private:
186 scoped_ptr<CriticalSectionWrapper> capture_cs_;
187 VideoCaptureCapability capability_;
188 int capture_delay_;
189 int64_t last_render_time_ms_;
190 int incoming_frames_;
191 int timing_warnings_;
192 webrtc::VideoFrame last_frame_;
193 webrtc::VideoRotation rotate_frame_;
194 };
195
196 class TestVideoCaptureFeedBack : public VideoCaptureFeedBack {
197 public:
TestVideoCaptureFeedBack()198 TestVideoCaptureFeedBack() :
199 capture_cs_(CriticalSectionWrapper::CreateCriticalSection()),
200 frame_rate_(0),
201 alarm_(webrtc::Cleared) {
202 }
203
OnCaptureFrameRate(const int32_t id,const uint32_t frameRate)204 virtual void OnCaptureFrameRate(const int32_t id,
205 const uint32_t frameRate) {
206 CriticalSectionScoped cs(capture_cs_.get());
207 frame_rate_ = frameRate;
208 }
209
OnNoPictureAlarm(const int32_t id,const VideoCaptureAlarm reported_alarm)210 virtual void OnNoPictureAlarm(const int32_t id,
211 const VideoCaptureAlarm reported_alarm) {
212 CriticalSectionScoped cs(capture_cs_.get());
213 alarm_ = reported_alarm;
214 }
frame_rate()215 int frame_rate() {
216 CriticalSectionScoped cs(capture_cs_.get());
217 return frame_rate_;
218
219 }
alarm()220 VideoCaptureAlarm alarm() {
221 CriticalSectionScoped cs(capture_cs_.get());
222 return alarm_;
223 }
224
225 private:
226 scoped_ptr<CriticalSectionWrapper> capture_cs_;
227 unsigned int frame_rate_;
228 VideoCaptureAlarm alarm_;
229 };
230
231 class VideoCaptureTest : public testing::Test {
232 public:
VideoCaptureTest()233 VideoCaptureTest() : number_of_devices_(0) {}
234
SetUp()235 void SetUp() {
236 device_info_.reset(VideoCaptureFactory::CreateDeviceInfo(0));
237 assert(device_info_.get());
238 number_of_devices_ = device_info_->NumberOfDevices();
239 ASSERT_GT(number_of_devices_, 0u);
240 }
241
OpenVideoCaptureDevice(unsigned int device,VideoCaptureDataCallback * callback)242 rtc::scoped_refptr<VideoCaptureModule> OpenVideoCaptureDevice(
243 unsigned int device,
244 VideoCaptureDataCallback* callback) {
245 char device_name[256];
246 char unique_name[256];
247
248 EXPECT_EQ(0, device_info_->GetDeviceName(
249 device, device_name, 256, unique_name, 256));
250
251 rtc::scoped_refptr<VideoCaptureModule> module(
252 VideoCaptureFactory::Create(device, unique_name));
253 if (module.get() == NULL)
254 return NULL;
255
256 EXPECT_FALSE(module->CaptureStarted());
257
258 module->RegisterCaptureDataCallback(*callback);
259 return module;
260 }
261
StartCapture(VideoCaptureModule * capture_module,VideoCaptureCapability capability)262 void StartCapture(VideoCaptureModule* capture_module,
263 VideoCaptureCapability capability) {
264 ASSERT_EQ(0, capture_module->StartCapture(capability));
265 EXPECT_TRUE(capture_module->CaptureStarted());
266
267 VideoCaptureCapability resulting_capability;
268 EXPECT_EQ(0, capture_module->CaptureSettings(resulting_capability));
269 EXPECT_EQ(capability.width, resulting_capability.width);
270 EXPECT_EQ(capability.height, resulting_capability.height);
271 }
272
273 scoped_ptr<VideoCaptureModule::DeviceInfo> device_info_;
274 unsigned int number_of_devices_;
275 };
276
277 #ifdef WEBRTC_MAC
278 // Currently fails on Mac 64-bit, see
279 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5406
280 #define MAYBE_CreateDelete DISABLED_CreateDelete
281 #else
282 #define MAYBE_CreateDelete CreateDelete
283 #endif
TEST_F(VideoCaptureTest,MAYBE_CreateDelete)284 TEST_F(VideoCaptureTest, MAYBE_CreateDelete) {
285 for (int i = 0; i < 5; ++i) {
286 int64_t start_time = TickTime::MillisecondTimestamp();
287 TestVideoCaptureCallback capture_observer;
288 rtc::scoped_refptr<VideoCaptureModule> module(
289 OpenVideoCaptureDevice(0, &capture_observer));
290 ASSERT_TRUE(module.get() != NULL);
291
292 VideoCaptureCapability capability;
293 #ifndef WEBRTC_MAC
294 device_info_->GetCapability(module->CurrentDeviceName(), 0, capability);
295 #else
296 capability.width = kTestWidth;
297 capability.height = kTestHeight;
298 capability.maxFPS = kTestFramerate;
299 capability.rawType = webrtc::kVideoUnknown;
300 #endif
301 capture_observer.SetExpectedCapability(capability);
302 ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability));
303
304 // Less than 4s to start the camera.
305 EXPECT_LE(TickTime::MillisecondTimestamp() - start_time, 4000);
306
307 // Make sure 5 frames are captured.
308 EXPECT_TRUE_WAIT(capture_observer.incoming_frames() >= 5, kTimeOut);
309
310 EXPECT_GE(capture_observer.capture_delay(), 0);
311
312 int64_t stop_time = TickTime::MillisecondTimestamp();
313 EXPECT_EQ(0, module->StopCapture());
314 EXPECT_FALSE(module->CaptureStarted());
315
316 // Less than 3s to stop the camera.
317 EXPECT_LE(TickTime::MillisecondTimestamp() - stop_time, 3000);
318 }
319 }
320
321 #ifdef WEBRTC_MAC
322 // Currently fails on Mac 64-bit, see
323 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5406
324 #define MAYBE_Capabilities DISABLED_Capabilities
325 #else
326 #define MAYBE_Capabilities Capabilities
327 #endif
TEST_F(VideoCaptureTest,MAYBE_Capabilities)328 TEST_F(VideoCaptureTest, MAYBE_Capabilities) {
329 #ifdef WEBRTC_MAC
330 printf("Video capture capabilities are not supported on Mac.\n");
331 return;
332 #endif
333
334 TestVideoCaptureCallback capture_observer;
335
336 rtc::scoped_refptr<VideoCaptureModule> module(
337 OpenVideoCaptureDevice(0, &capture_observer));
338 ASSERT_TRUE(module.get() != NULL);
339
340 int number_of_capabilities = device_info_->NumberOfCapabilities(
341 module->CurrentDeviceName());
342 EXPECT_GT(number_of_capabilities, 0);
343 // Key is <width>x<height>, value is vector of maxFPS values at that
344 // resolution.
345 typedef std::map<std::string, std::vector<int> > FrameRatesByResolution;
346 FrameRatesByResolution frame_rates_by_resolution;
347 for (int i = 0; i < number_of_capabilities; ++i) {
348 VideoCaptureCapability capability;
349 EXPECT_EQ(0, device_info_->GetCapability(module->CurrentDeviceName(), i,
350 capability));
351 std::ostringstream resolutionStream;
352 resolutionStream << capability.width << "x" << capability.height;
353 resolutionStream.flush();
354 std::string resolution = resolutionStream.str();
355 frame_rates_by_resolution[resolution].push_back(capability.maxFPS);
356
357 // Since Android presents so many resolution/FPS combinations and the test
358 // runner imposes a timeout, we only actually start the capture and test
359 // that a frame was captured for 2 frame-rates at each resolution.
360 if (frame_rates_by_resolution[resolution].size() > 2)
361 continue;
362
363 capture_observer.SetExpectedCapability(capability);
364 ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability));
365 // Make sure at least one frame is captured.
366 EXPECT_TRUE_WAIT(capture_observer.incoming_frames() >= 1, kTimeOut);
367
368 EXPECT_EQ(0, module->StopCapture());
369 }
370
371 #if ANDROID
372 // There's no reason for this to _necessarily_ be true, but in practice all
373 // Android devices this test runs on in fact do support multiple capture
374 // resolutions and multiple frame-rates per captured resolution, so we assert
375 // this fact here as a regression-test against the time that we only noticed a
376 // single frame-rate per resolution (bug 2974). If this test starts being run
377 // on devices for which this is untrue (e.g. Nexus4) then the following should
378 // probably be wrapped in a base::android::BuildInfo::model()/device() check.
379 EXPECT_GT(frame_rates_by_resolution.size(), 1U);
380 for (FrameRatesByResolution::const_iterator it =
381 frame_rates_by_resolution.begin();
382 it != frame_rates_by_resolution.end();
383 ++it) {
384 EXPECT_GT(it->second.size(), 1U) << it->first;
385 }
386 #endif // ANDROID
387 }
388
389 // NOTE: flaky, crashes sometimes.
390 // http://code.google.com/p/webrtc/issues/detail?id=777
TEST_F(VideoCaptureTest,DISABLED_TestTwoCameras)391 TEST_F(VideoCaptureTest, DISABLED_TestTwoCameras) {
392 if (number_of_devices_ < 2) {
393 printf("There are not two cameras available. Aborting test. \n");
394 return;
395 }
396
397 TestVideoCaptureCallback capture_observer1;
398 rtc::scoped_refptr<VideoCaptureModule> module1(
399 OpenVideoCaptureDevice(0, &capture_observer1));
400 ASSERT_TRUE(module1.get() != NULL);
401 VideoCaptureCapability capability1;
402 #ifndef WEBRTC_MAC
403 device_info_->GetCapability(module1->CurrentDeviceName(), 0, capability1);
404 #else
405 capability1.width = kTestWidth;
406 capability1.height = kTestHeight;
407 capability1.maxFPS = kTestFramerate;
408 capability1.rawType = webrtc::kVideoUnknown;
409 #endif
410 capture_observer1.SetExpectedCapability(capability1);
411
412 TestVideoCaptureCallback capture_observer2;
413 rtc::scoped_refptr<VideoCaptureModule> module2(
414 OpenVideoCaptureDevice(1, &capture_observer2));
415 ASSERT_TRUE(module1.get() != NULL);
416
417
418 VideoCaptureCapability capability2;
419 #ifndef WEBRTC_MAC
420 device_info_->GetCapability(module2->CurrentDeviceName(), 0, capability2);
421 #else
422 capability2.width = kTestWidth;
423 capability2.height = kTestHeight;
424 capability2.maxFPS = kTestFramerate;
425 capability2.rawType = webrtc::kVideoUnknown;
426 #endif
427 capture_observer2.SetExpectedCapability(capability2);
428
429 ASSERT_NO_FATAL_FAILURE(StartCapture(module1.get(), capability1));
430 ASSERT_NO_FATAL_FAILURE(StartCapture(module2.get(), capability2));
431 EXPECT_TRUE_WAIT(capture_observer1.incoming_frames() >= 5, kTimeOut);
432 EXPECT_TRUE_WAIT(capture_observer2.incoming_frames() >= 5, kTimeOut);
433 EXPECT_EQ(0, module2->StopCapture());
434 EXPECT_EQ(0, module1->StopCapture());
435 }
436
437 // Test class for testing external capture and capture feedback information
438 // such as frame rate and picture alarm.
439 class VideoCaptureExternalTest : public testing::Test {
440 public:
SetUp()441 void SetUp() {
442 capture_module_ = VideoCaptureFactory::Create(0, capture_input_interface_);
443 process_module_ = webrtc::ProcessThread::Create("ProcessThread");
444 process_module_->Start();
445 process_module_->RegisterModule(capture_module_);
446
447 VideoCaptureCapability capability;
448 capability.width = kTestWidth;
449 capability.height = kTestHeight;
450 capability.rawType = webrtc::kVideoYV12;
451 capability.maxFPS = kTestFramerate;
452 capture_callback_.SetExpectedCapability(capability);
453
454 test_frame_.CreateEmptyFrame(kTestWidth, kTestHeight, kTestWidth,
455 ((kTestWidth + 1) / 2), (kTestWidth + 1) / 2);
456 SleepMs(1); // Wait 1ms so that two tests can't have the same timestamp.
457 memset(test_frame_.buffer(webrtc::kYPlane), 127, kTestWidth * kTestHeight);
458 memset(test_frame_.buffer(webrtc::kUPlane), 127,
459 ((kTestWidth + 1) / 2) * ((kTestHeight + 1) / 2));
460 memset(test_frame_.buffer(webrtc::kVPlane), 127,
461 ((kTestWidth + 1) / 2) * ((kTestHeight + 1) / 2));
462
463 capture_module_->RegisterCaptureDataCallback(capture_callback_);
464 capture_module_->RegisterCaptureCallback(capture_feedback_);
465 capture_module_->EnableFrameRateCallback(true);
466 capture_module_->EnableNoPictureAlarm(true);
467 }
468
TearDown()469 void TearDown() {
470 process_module_->Stop();
471 }
472
473 webrtc::VideoCaptureExternal* capture_input_interface_;
474 rtc::scoped_refptr<VideoCaptureModule> capture_module_;
475 rtc::scoped_ptr<webrtc::ProcessThread> process_module_;
476 webrtc::VideoFrame test_frame_;
477 TestVideoCaptureCallback capture_callback_;
478 TestVideoCaptureFeedBack capture_feedback_;
479 };
480
481 // Test input of external video frames.
TEST_F(VideoCaptureExternalTest,TestExternalCapture)482 TEST_F(VideoCaptureExternalTest, TestExternalCapture) {
483 size_t length = webrtc::CalcBufferSize(webrtc::kI420,
484 test_frame_.width(),
485 test_frame_.height());
486 scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
487 webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
488 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
489 length, capture_callback_.capability(), 0));
490 EXPECT_TRUE(capture_callback_.CompareLastFrame(test_frame_));
491 }
492
493 // Test frame rate and no picture alarm.
494 // Flaky on Win32, see webrtc:3270.
495 #if defined(WEBRTC_WIN)
496 #define MAYBE_FrameRate DISABLED_FrameRate
497 #else
498 #define MAYBE_FrameRate FrameRate
499 #endif
TEST_F(VideoCaptureExternalTest,MAYBE_FrameRate)500 TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
501 int64_t testTime = 3;
502 TickTime startTime = TickTime::Now();
503
504 while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
505 size_t length = webrtc::CalcBufferSize(webrtc::kI420,
506 test_frame_.width(),
507 test_frame_.height());
508 scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
509 webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
510 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
511 length, capture_callback_.capability(), 0));
512 SleepMs(100);
513 }
514 EXPECT_TRUE(capture_feedback_.frame_rate() >= 8 &&
515 capture_feedback_.frame_rate() <= 10);
516 SleepMs(500);
517 EXPECT_EQ(webrtc::Raised, capture_feedback_.alarm());
518
519 startTime = TickTime::Now();
520 while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
521 size_t length = webrtc::CalcBufferSize(webrtc::kI420,
522 test_frame_.width(),
523 test_frame_.height());
524 scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
525 webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
526 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
527 length, capture_callback_.capability(), 0));
528 SleepMs(1000 / 30);
529 }
530 EXPECT_EQ(webrtc::Cleared, capture_feedback_.alarm());
531 // Frame rate might be less than 33 since we have paused providing
532 // frames for a while.
533 EXPECT_TRUE(capture_feedback_.frame_rate() >= 25 &&
534 capture_feedback_.frame_rate() <= 33);
535 }
536
TEST_F(VideoCaptureExternalTest,Rotation)537 TEST_F(VideoCaptureExternalTest, Rotation) {
538 EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_0));
539 size_t length = webrtc::CalcBufferSize(webrtc::kI420,
540 test_frame_.width(),
541 test_frame_.height());
542 scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
543 webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
544 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
545 length, capture_callback_.capability(), 0));
546 EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_90));
547 capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_90);
548 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
549 length, capture_callback_.capability(), 0));
550 EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_180));
551 capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_180);
552 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
553 length, capture_callback_.capability(), 0));
554 EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_270));
555 capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_270);
556 EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
557 length, capture_callback_.capability(), 0));
558 }
559