media/video/capture/video_capture_device_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/synchronization/waitable_event.h"
   8 #include "base/test/test_timeouts.h"
   9 #include "base/threading/thread.h"
  10 #include "media/video/capture/fake_video_capture_device.h"
  11 #include "media/video/capture/video_capture_device.h"
  12 #include "media/video/capture/video_capture_types.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 #if defined(OS_WIN)
  17 #include "base/win/scoped_com_initializer.h"
  18 #include "media/video/capture/win/video_capture_device_mf_win.h"
  19 #endif
  20
  21 #if defined(OS_ANDROID)
  22 #include "base/android/jni_android.h"
  23 #include "media/video/capture/android/video_capture_device_android.h"
  24 #endif
  25
  26 #if defined(OS_MACOSX)
  27 // Mac/QTKit will always give you the size you ask for and this case will fail.
  28 #define MAYBE_AllocateBadSize DISABLED_AllocateBadSize
  29 // We will always get ARGB from the Mac/QTKit implementation.
  30 #define MAYBE_CaptureMjpeg DISABLED_CaptureMjpeg
  31 #elif defined(OS_WIN)
  32 #define MAYBE_AllocateBadSize AllocateBadSize
  33 // Windows currently uses DirectShow to convert from MJPEG and a raw format is
  34 // always delivered.
  35 #define MAYBE_CaptureMjpeg DISABLED_CaptureMjpeg
  36 #elif defined(OS_ANDROID)
  37 // TODO(wjia): enable those tests on Android.
  38 // On Android, native camera (JAVA) delivers frames on UI thread which is the
  39 // main thread for tests. This results in no frame received by
  40 // VideoCaptureAndroid.
  41 #define CaptureVGA DISABLED_CaptureVGA
  42 #define Capture720p DISABLED_Capture720p
  43 #define MAYBE_AllocateBadSize DISABLED_AllocateBadSize
  44 #define ReAllocateCamera DISABLED_ReAllocateCamera
  45 #define DeAllocateCameraWhileRunning DISABLED_DeAllocateCameraWhileRunning
  46 #define DeAllocateCameraWhileRunning DISABLED_DeAllocateCameraWhileRunning
  47 #define MAYBE_CaptureMjpeg DISABLED_CaptureMjpeg
  48 #else
  49 #define MAYBE_AllocateBadSize AllocateBadSize
  50 #define MAYBE_CaptureMjpeg CaptureMjpeg
  51 #endif
  52
  53 using ::testing::_;
  54 using ::testing::AnyNumber;
  55 using ::testing::Return;
  56 using ::testing::AtLeast;
  57 using ::testing::SaveArg;
  58
  59 namespace media {
  60
  61 class MockFrameObserver : public media::VideoCaptureDevice::EventHandler {
  62  public:
  63   MOCK_METHOD0(ReserveOutputBuffer, scoped_refptr<media::VideoFrame>());
  64   MOCK_METHOD0(OnErr, void());
  65   MOCK_METHOD1(OnFrameInfo, void(const VideoCaptureCapability&));
  66   MOCK_METHOD1(OnFrameInfoChanged, void(const VideoCaptureCapability&));
  67
  68   explicit MockFrameObserver(base::WaitableEvent* wait_event)
  69      : wait_event_(wait_event) {}
  70
  71   virtual void OnError() OVERRIDE {
  72     OnErr();
  73   }
  74
  75   virtual void OnIncomingCapturedFrame(
  76       const uint8* data,
  77       int length,
  78       base::Time timestamp,
  79       int rotation,
  80       bool flip_vert,
  81       bool flip_horiz) OVERRIDE {
  82     wait_event_->Signal();
  83   }
  84
  85   virtual void OnIncomingCapturedVideoFrame(
  86       const scoped_refptr<media::VideoFrame>& frame,
  87       base::Time timestamp) OVERRIDE {
  88     wait_event_->Signal();
  89   }
  90
  91  private:
  92   base::WaitableEvent* wait_event_;
  93 };
  94
  95 class VideoCaptureDeviceTest : public testing::Test {
  96  public:
  97   VideoCaptureDeviceTest(): wait_event_(false, false) { }
  98
  99   void PostQuitTask() {
 100     loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 101     loop_->Run();
 102   }
 103
 104  protected:
 105   virtual void SetUp() {
 106     frame_observer_.reset(new MockFrameObserver(&wait_event_));
 107     loop_.reset(new base::MessageLoopForUI());
 108 #if defined(OS_ANDROID)
 109     media::VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(
 110         base::android::AttachCurrentThread());
 111 #endif
 112   }
 113
 114   virtual void TearDown() {
 115   }
 116
 117 #if defined(OS_WIN)
 118   base::win::ScopedCOMInitializer initialize_com_;
 119 #endif
 120   base::WaitableEvent wait_event_;
 121   scoped_ptr<MockFrameObserver> frame_observer_;
 122   VideoCaptureDevice::Names names_;
 123   scoped_ptr<base::MessageLoop> loop_;
 124 };
 125
 126 TEST_F(VideoCaptureDeviceTest, OpenInvalidDevice) {
 127 #if defined(OS_WIN)
 128   VideoCaptureDevice::Name::CaptureApiType api_type =
 129       VideoCaptureDeviceMFWin::PlatformSupported()
 130           ? VideoCaptureDevice::Name::MEDIA_FOUNDATION
 131           : VideoCaptureDevice::Name::DIRECT_SHOW;
 132   VideoCaptureDevice::Name device_name("jibberish", "jibberish", api_type);
 133 #else
 134   VideoCaptureDevice::Name device_name("jibberish", "jibberish");
 135 #endif
 136   VideoCaptureDevice* device = VideoCaptureDevice::Create(device_name);
 137   EXPECT_TRUE(device == NULL);
 138 }
 139
 140 TEST_F(VideoCaptureDeviceTest, CaptureVGA) {
 141   VideoCaptureDevice::GetDeviceNames(&names_);
 142   if (!names_.size()) {
 143     DVLOG(1) << "No camera available. Exiting test.";
 144     return;
 145   }
 146
 147   scoped_ptr<VideoCaptureDevice> device(
 148       VideoCaptureDevice::Create(names_.front()));
 149   ASSERT_FALSE(device.get() == NULL);
 150   DVLOG(1) << names_.front().id();
 151   // Get info about the new resolution.
 152   VideoCaptureCapability rx_capability;
 153   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 154       .Times(1).WillOnce(SaveArg<0>(&rx_capability));
 155
 156   EXPECT_CALL(*frame_observer_, OnErr())
 157       .Times(0);
 158
 159   VideoCaptureCapability capture_format(640,
 160                                         480,
 161                                         30,
 162                                         VideoCaptureCapability::kI420,
 163                                         0,
 164                                         false,
 165                                         ConstantResolutionVideoCaptureDevice);
 166   device->Allocate(capture_format, frame_observer_.get());
 167   device->Start();
 168   // Get captured video frames.
 169   PostQuitTask();
 170   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 171   EXPECT_EQ(rx_capability.width, 640);
 172   EXPECT_EQ(rx_capability.height, 480);
 173   device->Stop();
 174   device->DeAllocate();
 175 }
 176
 177 TEST_F(VideoCaptureDeviceTest, Capture720p) {
 178   VideoCaptureDevice::GetDeviceNames(&names_);
 179   if (!names_.size()) {
 180     DVLOG(1) << "No camera available. Exiting test.";
 181     return;
 182   }
 183
 184   scoped_ptr<VideoCaptureDevice> device(
 185       VideoCaptureDevice::Create(names_.front()));
 186   ASSERT_FALSE(device.get() == NULL);
 187
 188   // Get info about the new resolution.
 189   // We don't care about the resulting resolution or frame rate as it might
 190   // be different from one machine to the next.
 191   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 192       .Times(1);
 193
 194   EXPECT_CALL(*frame_observer_, OnErr())
 195       .Times(0);
 196
 197   VideoCaptureCapability capture_format(1280,
 198                                         720,
 199                                         30,
 200                                         VideoCaptureCapability::kI420,
 201                                         0,
 202                                         false,
 203                                         ConstantResolutionVideoCaptureDevice);
 204   device->Allocate(capture_format, frame_observer_.get());
 205   device->Start();
 206   // Get captured video frames.
 207   PostQuitTask();
 208   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 209   device->Stop();
 210   device->DeAllocate();
 211 }
 212
 213 TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
 214   VideoCaptureDevice::GetDeviceNames(&names_);
 215   if (!names_.size()) {
 216     DVLOG(1) << "No camera available. Exiting test.";
 217     return;
 218   }
 219   scoped_ptr<VideoCaptureDevice> device(
 220       VideoCaptureDevice::Create(names_.front()));
 221   ASSERT_TRUE(device.get() != NULL);
 222
 223   EXPECT_CALL(*frame_observer_, OnErr())
 224       .Times(0);
 225
 226   // Get info about the new resolution.
 227   VideoCaptureCapability rx_capability;
 228   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 229       .Times(AtLeast(1)).WillOnce(SaveArg<0>(&rx_capability));
 230
 231   VideoCaptureCapability capture_format(637,
 232                                         472,
 233                                         35,
 234                                         VideoCaptureCapability::kI420,
 235                                         0,
 236                                         false,
 237                                         ConstantResolutionVideoCaptureDevice);
 238   device->Allocate(capture_format, frame_observer_.get());
 239   device->DeAllocate();
 240   EXPECT_EQ(rx_capability.width, 640);
 241   EXPECT_EQ(rx_capability.height, 480);
 242 }
 243
 244 TEST_F(VideoCaptureDeviceTest, ReAllocateCamera) {
 245   VideoCaptureDevice::GetDeviceNames(&names_);
 246   if (!names_.size()) {
 247     DVLOG(1) << "No camera available. Exiting test.";
 248     return;
 249   }
 250   scoped_ptr<VideoCaptureDevice> device(
 251       VideoCaptureDevice::Create(names_.front()));
 252   ASSERT_TRUE(device.get() != NULL);
 253   EXPECT_CALL(*frame_observer_, OnErr())
 254       .Times(0);
 255   // Get info about the new resolution.
 256   VideoCaptureCapability rx_capability_1;
 257   VideoCaptureCapability rx_capability_2;
 258   VideoCaptureCapability capture_format_1(640,
 259                                           480,
 260                                           30,
 261                                           VideoCaptureCapability::kI420,
 262                                           0,
 263                                           false,
 264                                           ConstantResolutionVideoCaptureDevice);
 265   VideoCaptureCapability capture_format_2(1280,
 266                                           1024,
 267                                           30,
 268                                           VideoCaptureCapability::kI420,
 269                                           0,
 270                                           false,
 271                                           ConstantResolutionVideoCaptureDevice);
 272   VideoCaptureCapability capture_format_3(320,
 273                                           240,
 274                                           30,
 275                                           VideoCaptureCapability::kI420,
 276                                           0,
 277                                           false,
 278                                           ConstantResolutionVideoCaptureDevice);
 279
 280   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 281       .WillOnce(SaveArg<0>(&rx_capability_1));
 282   device->Allocate(capture_format_1, frame_observer_.get());
 283   device->Start();
 284   // Nothing shall happen.
 285   device->Allocate(capture_format_2, frame_observer_.get());
 286   device->DeAllocate();
 287   // Allocate new size 320, 240
 288   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 289       .WillOnce(SaveArg<0>(&rx_capability_2));
 290   device->Allocate(capture_format_3, frame_observer_.get());
 291
 292   device->Start();
 293   // Get captured video frames.
 294   PostQuitTask();
 295   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 296   EXPECT_EQ(rx_capability_1.width, 640);
 297   EXPECT_EQ(rx_capability_1.height, 480);
 298   EXPECT_EQ(rx_capability_2.width, 320);
 299   EXPECT_EQ(rx_capability_2.height, 240);
 300   device->Stop();
 301   device->DeAllocate();
 302 }
 303
 304 TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
 305   VideoCaptureDevice::GetDeviceNames(&names_);
 306   if (!names_.size()) {
 307     DVLOG(1) << "No camera available. Exiting test.";
 308     return;
 309   }
 310   scoped_ptr<VideoCaptureDevice> device(
 311       VideoCaptureDevice::Create(names_.front()));
 312   ASSERT_TRUE(device.get() != NULL);
 313
 314   EXPECT_CALL(*frame_observer_, OnErr())
 315       .Times(0);
 316   // Get info about the new resolution.
 317   VideoCaptureCapability rx_capability;
 318   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 319       .WillOnce(SaveArg<0>(&rx_capability));
 320
 321   VideoCaptureCapability capture_format(640,
 322                                         480,
 323                                         30,
 324                                         VideoCaptureCapability::kI420,
 325                                         0,
 326                                         false,
 327                                         ConstantResolutionVideoCaptureDevice);
 328   device->Allocate(capture_format, frame_observer_.get());
 329
 330   device->Start();
 331   // Get captured video frames.
 332   PostQuitTask();
 333   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 334   EXPECT_EQ(rx_capability.width, 640);
 335   EXPECT_EQ(rx_capability.height, 480);
 336   EXPECT_EQ(rx_capability.frame_rate, 30);
 337   device->DeAllocate();
 338 }
 339
 340 TEST_F(VideoCaptureDeviceTest, FakeCapture) {
 341   VideoCaptureDevice::Names names;
 342
 343   FakeVideoCaptureDevice::GetDeviceNames(&names);
 344
 345   ASSERT_GT(static_cast<int>(names.size()), 0);
 346
 347   scoped_ptr<VideoCaptureDevice> device(
 348       FakeVideoCaptureDevice::Create(names.front()));
 349   ASSERT_TRUE(device.get() != NULL);
 350
 351   // Get info about the new resolution.
 352   VideoCaptureCapability rx_capability;
 353   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 354       .Times(1).WillOnce(SaveArg<0>(&rx_capability));
 355
 356   EXPECT_CALL(*frame_observer_, OnErr())
 357       .Times(0);
 358
 359   VideoCaptureCapability capture_format(640,
 360                                         480,
 361                                         30,
 362                                         VideoCaptureCapability::kI420,
 363                                         0,
 364                                         false,
 365                                         ConstantResolutionVideoCaptureDevice);
 366   device->Allocate(capture_format, frame_observer_.get());
 367
 368   device->Start();
 369   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 370   EXPECT_EQ(rx_capability.width, 640);
 371   EXPECT_EQ(rx_capability.height, 480);
 372   EXPECT_EQ(rx_capability.frame_rate, 30);
 373   device->Stop();
 374   device->DeAllocate();
 375 }
 376
 377 // Start the camera in 720p to capture MJPEG instead of a raw format.
 378 TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
 379   VideoCaptureDevice::GetDeviceNames(&names_);
 380   if (!names_.size()) {
 381     DVLOG(1) << "No camera available. Exiting test.";
 382     return;
 383   }
 384   scoped_ptr<VideoCaptureDevice> device(
 385       VideoCaptureDevice::Create(names_.front()));
 386   ASSERT_TRUE(device.get() != NULL);
 387
 388   EXPECT_CALL(*frame_observer_, OnErr())
 389       .Times(0);
 390   // Verify we get MJPEG from the device. Not all devices can capture 1280x720
 391   // @ 30 fps, so we don't care about the exact resolution we get.
 392   VideoCaptureCapability rx_capability;
 393   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 394       .WillOnce(SaveArg<0>(&rx_capability));
 395
 396   VideoCaptureCapability capture_format(1280,
 397                                         720,
 398                                         30,
 399                                         VideoCaptureCapability::kMJPEG,
 400                                         0,
 401                                         false,
 402                                         ConstantResolutionVideoCaptureDevice);
 403   device->Allocate(capture_format, frame_observer_.get());
 404
 405   device->Start();
 406   // Get captured video frames.
 407   PostQuitTask();
 408   EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_max_timeout()));
 409   EXPECT_EQ(rx_capability.color, VideoCaptureCapability::kMJPEG);
 410   device->DeAllocate();
 411 }
 412
 413 TEST_F(VideoCaptureDeviceTest, FakeCaptureVariableResolution) {
 414   VideoCaptureDevice::Names names;
 415
 416   FakeVideoCaptureDevice::GetDeviceNames(&names);
 417   media::VideoCaptureCapability capture_format;
 418   capture_format.width = 640;
 419   capture_format.height = 480;
 420   capture_format.frame_rate = 30;
 421   capture_format.frame_size_type = media::VariableResolutionVideoCaptureDevice;
 422
 423   ASSERT_GT(static_cast<int>(names.size()), 0);
 424
 425   scoped_ptr<VideoCaptureDevice> device(
 426       FakeVideoCaptureDevice::Create(names.front()));
 427   ASSERT_TRUE(device.get() != NULL);
 428
 429   // Get info about the new resolution.
 430   EXPECT_CALL(*frame_observer_, OnFrameInfo(_))
 431       .Times(1);
 432
 433   EXPECT_CALL(*frame_observer_, OnErr())
 434       .Times(0);
 435
 436   device->Allocate(capture_format, frame_observer_.get());
 437
 438   // The amount of times the OnFrameInfoChanged gets called depends on how often
 439   // FakeDevice is supposed to change and what is its actual frame rate.
 440   // We set TimeWait to 200 action timeouts and this should be enough for at
 441   // least action_count/kFakeCaptureCapabilityChangePeriod calls.
 442   int action_count = 200;
 443   EXPECT_CALL(*frame_observer_, OnFrameInfoChanged(_))
 444       .Times(AtLeast(action_count / 30));
 445   device->Start();
 446   for (int i = 0; i < action_count; ++i) {
 447     EXPECT_TRUE(wait_event_.TimedWait(TestTimeouts::action_timeout()));
 448   }
 449   device->Stop();
 450   device->DeAllocate();
 451 }
 452
 453 };  // namespace media