Add Intel Perceptual Computing SDK based depth video capture for Windows

media/video/capture/win/video_capture_device_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/video/capture/win/video_capture_device_win.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/windows_version.h"
 #include "media/base/media_switches.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
+#include "media/video/capture/win/video_capture_device_pxc_win.h"
+
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 namespace {
 
 // Finds and creates a DirectShow Video Capture filter matching the device_name.
 HRESULT GetDeviceFilter(const VideoCaptureDevice::Name& device_name,
@@ skipping 184 matching lines @@
   // DirectShow for any other versions, unless forced via flag. Media Foundation
   // can also be forced if appropriate flag is set and we are in Windows 7 or
   // 8 in non-Metro mode.
   if ((base::win::IsMetroProcess() &&
       !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
       (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
       cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
     VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
   } else {
     VideoCaptureDeviceWin::GetDeviceNames(device_names);
+    if (cmd_line->HasSwitch(switches::kEnableDepthCamera)) {
+      if (VideoCaptureDevicePXCWin::PlatformSupported()) {
+        VideoCaptureDevicePXCWin::AppendDeviceNames(device_names);
+      }
+    }
   }
 }
 
 // static
 void VideoCaptureDevice::GetDeviceSupportedFormats(const Name& device,
     VideoCaptureFormats* formats) {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   // Use Media Foundation for Metro processes (after and including Win8) and
   // DirectShow for any other versions, unless forced via flag. Media Foundation
   // can also be forced if appropriate flag is set and we are in Windows 7 or
   // 8 in non-Metro mode.
   if ((base::win::IsMetroProcess() &&
       !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
       (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
       cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
     VideoCaptureDeviceMFWin::GetDeviceSupportedFormats(device, formats);
   } else {
+    if (cmd_line->HasSwitch(switches::kEnableDepthCamera)) {
+      if (VideoCaptureDevicePXCWin::IsDepthDevice(device)) {
+        VideoCaptureDevicePXCWin::GetDeviceSupportedFormats(device, formats);
+        return;
+      }
+    }
     VideoCaptureDeviceWin::GetDeviceSupportedFormats(device, formats);
   }
 }
 
 // static
 VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   VideoCaptureDevice* ret = NULL;
   if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
     DCHECK(VideoCaptureDeviceMFWin::PlatformSupported());
     scoped_ptr<VideoCaptureDeviceMFWin> device(
         new VideoCaptureDeviceMFWin(device_name));
     DVLOG(1) << " MediaFoundation Device: " << device_name.name();
     if (device->Init())
       ret = device.release();
   } else if (device_name.capture_api_type() == Name::DIRECT_SHOW) {
     scoped_ptr<VideoCaptureDeviceWin> device(
         new VideoCaptureDeviceWin(device_name));
     DVLOG(1) << " DirectShow Device: " << device_name.name();
     if (device->Init())
       ret = device.release();
-  } else{
+  } else if (cmd_line->HasSwitch(switches::kEnableDepthCamera) &&
+             device_name.capture_api_type() == Name::PXC_CAPTURE) {
+    DCHECK(VideoCaptureDevicePXCWin::PlatformSupported());
+    scoped_ptr<VideoCaptureDevicePXCWin> device(
+        new VideoCaptureDevicePXCWin(device_name));
+    DVLOG(1) << " PxcCapture Device: " << device_name.name();
+    if (device->Init())
+      ret = device.release();
+  } else {
     NOTREACHED() << " Couldn't recognize VideoCaptureDevice type";
   }
 
   return ret;
 }
 
 // static
 void VideoCaptureDeviceWin::GetDeviceNames(Names* device_names) {
   DCHECK(device_names);
 
@@ skipping 478 matching lines @@
   return !capabilities_.empty();
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media