← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/googletalk/libjingle/talk/session/phone/win32devicemanager.cc

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/googletalk/libjingle/talk/session/phone/win32devicemanager.cc
1
 
/*
2
 
 * libjingle
3
 
 * Copyright 2004 Google Inc.
4
 
 *
5
 
 * Redistribution and use in source and binary forms, with or without
6
 
 * modification, are permitted provided that the following conditions are met:
7
 
 *
8
 
 *  1. Redistributions of source code must retain the above copyright notice,
9
 
 *     this list of conditions and the following disclaimer.
10
 
 *  2. Redistributions in binary form must reproduce the above copyright notice,
11
 
 *     this list of conditions and the following disclaimer in the documentation
12
 
 *     and/or other materials provided with the distribution.
13
 
 *  3. The name of the author may not be used to endorse or promote products
14
 
 *     derived from this software without specific prior written permission.
15
 
 *
16
 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17
 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18
 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19
 
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20
 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21
 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22
 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23
 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24
 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25
 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 
 */
27
 
 
28
 
#include "talk/session/phone/win32devicemanager.h"
29
 
 
30
 
#include <atlbase.h>
31
 
#include <dbt.h>
32
 
#include <strmif.h>  // must come before ks.h
33
 
#include <ks.h>
34
 
#include <ksmedia.h>
35
 
#define INITGUID  // For PKEY_AudioEndpoint_GUID
36
 
#include <mmdeviceapi.h>
37
 
#include <mmsystem.h>
38
 
#include <functiondiscoverykeys_devpkey.h>
39
 
#include <uuids.h>
40
 
 
41
 
#include "talk/base/win32.h"  // ToUtf8
42
 
#include "talk/base/win32window.h"
43
 
#include "talk/base/logging.h"
44
 
#include "talk/base/stringutils.h"
45
 
#include "talk/base/thread.h"
46
 
#include "talk/session/phone/mediacommon.h"
47
 
#ifdef HAVE_LOGITECH_HEADERS
48
 
#include "third_party/logitech/files/logitechquickcam.h"
49
 
#endif
50
 
 
51
 
namespace cricket {
52
 
 
53
 
DeviceManagerInterface* DeviceManagerFactory::Create() {
54
 
  return new Win32DeviceManager();
55
 
}
56
 
 
57
 
class Win32DeviceWatcher
58
 
    : public DeviceWatcher,
59
 
      public talk_base::Win32Window {
60
 
 public:
61
 
  explicit Win32DeviceWatcher(Win32DeviceManager* dm);
62
 
  virtual ~Win32DeviceWatcher();
63
 
  virtual bool Start();
64
 
  virtual void Stop();
65
 
 
66
 
 private:
67
 
  HDEVNOTIFY Register(REFGUID guid);
68
 
  void Unregister(HDEVNOTIFY notify);
69
 
  virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
70
 
 
71
 
  Win32DeviceManager* manager_;
72
 
  HDEVNOTIFY audio_notify_;
73
 
  HDEVNOTIFY video_notify_;
74
 
};
75
 
 
76
 
static const char* kFilteredAudioDevicesName[] = {
77
 
    NULL,
78
 
};
79
 
static const char* const kFilteredVideoDevicesName[] =  {
80
 
    "Google Camera Adapter",   // Our own magiccams
81
 
    "Asus virtual Camera",     // Bad Asus desktop virtual cam
82
 
    "Bluetooth Video",         // Bad Sony viao bluetooth sharing driver
83
 
    NULL,
84
 
};
85
 
static const wchar_t kFriendlyName[] = L"FriendlyName";
86
 
static const wchar_t kDevicePath[] = L"DevicePath";
87
 
static const char kUsbDevicePathPrefix[] = "\\\\?\\usb";
88
 
static bool GetDevices(const CLSID& catid, std::vector<Device>* out);
89
 
static bool GetCoreAudioDevices(bool input, std::vector<Device>* devs);
90
 
static bool GetWaveDevices(bool input, std::vector<Device>* devs);
91
 
 
92
 
Win32DeviceManager::Win32DeviceManager()
93
 
    : need_couninitialize_(false) {
94
 
  set_watcher(new Win32DeviceWatcher(this));
95
 
}
96
 
 
97
 
Win32DeviceManager::~Win32DeviceManager() {
98
 
  if (initialized()) {
99
 
    Terminate();
100
 
  }
101
 
}
102
 
 
103
 
bool Win32DeviceManager::Init() {
104
 
  if (!initialized()) {
105
 
    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
106
 
    need_couninitialize_ = SUCCEEDED(hr);
107
 
    if (FAILED(hr)) {
108
 
      LOG(LS_ERROR) << "CoInitialize failed, hr=" << hr;
109
 
      if (hr != RPC_E_CHANGED_MODE) {
110
 
        return false;
111
 
      }
112
 
    }
113
 
    if (!watcher()->Start()) {
114
 
      return false;
115
 
    }
116
 
    set_initialized(true);
117
 
  }
118
 
  return true;
119
 
}
120
 
 
121
 
void Win32DeviceManager::Terminate() {
122
 
  if (initialized()) {
123
 
    watcher()->Stop();
124
 
    if (need_couninitialize_) {
125
 
      CoUninitialize();
126
 
      need_couninitialize_ = false;
127
 
    }
128
 
    set_initialized(false);
129
 
  }
130
 
}
131
 
 
132
 
bool Win32DeviceManager::GetDefaultVideoCaptureDevice(Device* device) {
133
 
  bool ret = false;
134
 
  // If there are multiple capture devices, we want the first USB one.
135
 
  // This avoids issues with defaulting to virtual cameras or grabber cards.
136
 
  std::vector<Device> devices;
137
 
  ret = (GetVideoCaptureDevices(&devices) && !devices.empty());
138
 
  if (ret) {
139
 
    *device = devices[0];
140
 
    for (size_t i = 0; i < devices.size(); ++i) {
141
 
      if (strnicmp(devices[i].id.c_str(), kUsbDevicePathPrefix,
142
 
                   ARRAY_SIZE(kUsbDevicePathPrefix) - 1) == 0) {
143
 
        *device = devices[i];
144
 
        break;
145
 
      }
146
 
    }
147
 
  }
148
 
  return ret;
149
 
}
150
 
 
151
 
bool Win32DeviceManager::GetAudioDevices(bool input,
152
 
                                         std::vector<Device>* devs) {
153
 
  devs->clear();
154
 
 
155
 
  if (talk_base::IsWindowsVistaOrLater()) {
156
 
    if (!GetCoreAudioDevices(input, devs))
157
 
      return false;
158
 
  } else {
159
 
    if (!GetWaveDevices(input, devs))
160
 
      return false;
161
 
  }
162
 
  return FilterDevices(devs, kFilteredAudioDevicesName);
163
 
}
164
 
 
165
 
bool Win32DeviceManager::GetVideoCaptureDevices(std::vector<Device>* devices) {
166
 
  devices->clear();
167
 
  if (!GetDevices(CLSID_VideoInputDeviceCategory, devices)) {
168
 
    return false;
169
 
  }
170
 
  return FilterDevices(devices, kFilteredVideoDevicesName);
171
 
}
172
 
 
173
 
bool GetDevices(const CLSID& catid, std::vector<Device>* devices) {
174
 
  HRESULT hr;
175
 
 
176
 
  // CComPtr is a scoped pointer that will be auto released when going
177
 
  // out of scope. CoUninitialize must not be called before the
178
 
  // release.
179
 
  CComPtr<ICreateDevEnum> sys_dev_enum;
180
 
  CComPtr<IEnumMoniker> cam_enum;
181
 
  if (FAILED(hr = sys_dev_enum.CoCreateInstance(CLSID_SystemDeviceEnum)) ||
182
 
      FAILED(hr = sys_dev_enum->CreateClassEnumerator(catid, &cam_enum, 0))) {
183
 
    LOG(LS_ERROR) << "Failed to create device enumerator, hr="  << hr;
184
 
    return false;
185
 
  }
186
 
 
187
 
  // Only enum devices if CreateClassEnumerator returns S_OK. If there are no
188
 
  // devices available, S_FALSE will be returned, but enumMk will be NULL.
189
 
  if (hr == S_OK) {
190
 
    CComPtr<IMoniker> mk;
191
 
    while (cam_enum->Next(1, &mk, NULL) == S_OK) {
192
 
#ifdef HAVE_LOGITECH_HEADERS
193
 
      // Initialize Logitech device if applicable
194
 
      MaybeLogitechDeviceReset(mk);
195
 
#endif
196
 
      CComPtr<IPropertyBag> bag;
197
 
      if (SUCCEEDED(mk->BindToStorage(NULL, NULL,
198
 
          __uuidof(bag), reinterpret_cast<void**>(&bag)))) {
199
 
        CComVariant name, path;
200
 
        std::string name_str, path_str;
201
 
        if (SUCCEEDED(bag->Read(kFriendlyName, &name, 0)) &&
202
 
            name.vt == VT_BSTR) {
203
 
          name_str = talk_base::ToUtf8(name.bstrVal);
204
 
          // Get the device id if one exists.
205
 
          if (SUCCEEDED(bag->Read(kDevicePath, &path, 0)) &&
206
 
              path.vt == VT_BSTR) {
207
 
            path_str = talk_base::ToUtf8(path.bstrVal);
208
 
          }
209
 
 
210
 
          devices->push_back(Device(name_str, path_str));
211
 
        }
212
 
      }
213
 
      mk = NULL;
214
 
    }
215
 
  }
216
 
 
217
 
  return true;
218
 
}
219
 
 
220
 
HRESULT GetStringProp(IPropertyStore* bag, PROPERTYKEY key, std::string* out) {
221
 
  out->clear();
222
 
  PROPVARIANT var;
223
 
  PropVariantInit(&var);
224
 
 
225
 
  HRESULT hr = bag->GetValue(key, &var);
226
 
  if (SUCCEEDED(hr)) {
227
 
    if (var.pwszVal)
228
 
      *out = talk_base::ToUtf8(var.pwszVal);
229
 
    else
230
 
      hr = E_FAIL;
231
 
  }
232
 
 
233
 
  PropVariantClear(&var);
234
 
  return hr;
235
 
}
236
 
 
237
 
// Adapted from http://msdn.microsoft.com/en-us/library/dd370812(v=VS.85).aspx
238
 
HRESULT CricketDeviceFromImmDevice(IMMDevice* device, Device* out) {
239
 
  CComPtr<IPropertyStore> props;
240
 
 
241
 
  HRESULT hr = device->OpenPropertyStore(STGM_READ, &props);
242
 
  if (FAILED(hr)) {
243
 
    return hr;
244
 
  }
245
 
 
246
 
  // Get the endpoint's name and id.
247
 
  std::string name, guid;
248
 
  hr = GetStringProp(props, PKEY_Device_FriendlyName, &name);
249
 
  if (SUCCEEDED(hr)) {
250
 
    hr = GetStringProp(props, PKEY_AudioEndpoint_GUID, &guid);
251
 
 
252
 
    if (SUCCEEDED(hr)) {
253
 
      out->name = name;
254
 
      out->id = guid;
255
 
    }
256
 
  }
257
 
  return hr;
258
 
}
259
 
 
260
 
bool GetCoreAudioDevices(
261
 
    bool input, std::vector<Device>* devs) {
262
 
  HRESULT hr = S_OK;
263
 
  CComPtr<IMMDeviceEnumerator> enumerator;
264
 
 
265
 
  hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL,
266
 
      __uuidof(IMMDeviceEnumerator), reinterpret_cast<void**>(&enumerator));
267
 
  if (SUCCEEDED(hr)) {
268
 
    CComPtr<IMMDeviceCollection> devices;
269
 
    hr = enumerator->EnumAudioEndpoints((input ? eCapture : eRender),
270
 
                                        DEVICE_STATE_ACTIVE, &devices);
271
 
    if (SUCCEEDED(hr)) {
272
 
      unsigned int count;
273
 
      hr = devices->GetCount(&count);
274
 
 
275
 
      if (SUCCEEDED(hr)) {
276
 
        for (unsigned int i = 0; i < count; i++) {
277
 
          CComPtr<IMMDevice> device;
278
 
 
279
 
          // Get pointer to endpoint number i.
280
 
          hr = devices->Item(i, &device);
281
 
          if (FAILED(hr)) {
282
 
            break;
283
 
          }
284
 
 
285
 
          Device dev;
286
 
          hr = CricketDeviceFromImmDevice(device, &dev);
287
 
          if (SUCCEEDED(hr)) {
288
 
            devs->push_back(dev);
289
 
          } else {
290
 
            LOG(LS_WARNING) << "Unable to query IMM Device, skipping.  HR="
291
 
                            << hr;
292
 
            hr = S_FALSE;
293
 
          }
294
 
        }
295
 
      }
296
 
    }
297
 
  }
298
 
 
299
 
  if (FAILED(hr)) {
300
 
    LOG(LS_WARNING) << "GetCoreAudioDevices failed with hr " << hr;
301
 
    return false;
302
 
  }
303
 
  return true;
304
 
}
305
 
 
306
 
bool GetWaveDevices(bool input, std::vector<Device>* devs) {
307
 
  // Note, we don't use the System Device Enumerator interface here since it
308
 
  // adds lots of pseudo-devices to the list, such as DirectSound and Wave
309
 
  // variants of the same device.
310
 
  if (input) {
311
 
    int num_devs = waveInGetNumDevs();
312
 
    for (int i = 0; i < num_devs; ++i) {
313
 
      WAVEINCAPS caps;
314
 
      if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
315
 
          caps.wChannels > 0) {
316
 
        devs->push_back(Device(talk_base::ToUtf8(caps.szPname),
317
 
                               talk_base::ToString(i)));
318
 
      }
319
 
    }
320
 
  } else {
321
 
    int num_devs = waveOutGetNumDevs();
322
 
    for (int i = 0; i < num_devs; ++i) {
323
 
      WAVEOUTCAPS caps;
324
 
      if (waveOutGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
325
 
          caps.wChannels > 0) {
326
 
        devs->push_back(Device(talk_base::ToUtf8(caps.szPname), i));
327
 
      }
328
 
    }
329
 
  }
330
 
  return true;
331
 
}
332
 
 
333
 
Win32DeviceWatcher::Win32DeviceWatcher(Win32DeviceManager* manager)
334
 
    : DeviceWatcher(manager),
335
 
      manager_(manager),
336
 
      audio_notify_(NULL),
337
 
      video_notify_(NULL) {
338
 
}
339
 
 
340
 
Win32DeviceWatcher::~Win32DeviceWatcher() {
341
 
}
342
 
 
343
 
bool Win32DeviceWatcher::Start() {
344
 
  if (!Create(NULL, _T("libjingle Win32DeviceWatcher Window"),
345
 
              0, 0, 0, 0, 0, 0)) {
346
 
    return false;
347
 
  }
348
 
 
349
 
  audio_notify_ = Register(KSCATEGORY_AUDIO);
350
 
  if (!audio_notify_) {
351
 
    Stop();
352
 
    return false;
353
 
  }
354
 
 
355
 
  video_notify_ = Register(KSCATEGORY_VIDEO);
356
 
  if (!video_notify_) {
357
 
    Stop();
358
 
    return false;
359
 
  }
360
 
 
361
 
  return true;
362
 
}
363
 
 
364
 
void Win32DeviceWatcher::Stop() {
365
 
  UnregisterDeviceNotification(video_notify_);
366
 
  video_notify_ = NULL;
367
 
  UnregisterDeviceNotification(audio_notify_);
368
 
  audio_notify_ = NULL;
369
 
  Destroy();
370
 
}
371
 
 
372
 
HDEVNOTIFY Win32DeviceWatcher::Register(REFGUID guid) {
373
 
  DEV_BROADCAST_DEVICEINTERFACE dbdi;
374
 
  dbdi.dbcc_size = sizeof(dbdi);
375
 
  dbdi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
376
 
  dbdi.dbcc_classguid = guid;
377
 
  dbdi.dbcc_name[0] = '\0';
378
 
  return RegisterDeviceNotification(handle(), &dbdi,
379
 
                                    DEVICE_NOTIFY_WINDOW_HANDLE);
380
 
}
381
 
 
382
 
void Win32DeviceWatcher::Unregister(HDEVNOTIFY handle) {
383
 
  UnregisterDeviceNotification(handle);
384
 
}
385
 
 
386
 
bool Win32DeviceWatcher::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
387
 
                              LRESULT& result) {
388
 
  if (uMsg == WM_DEVICECHANGE) {
389
 
    if (wParam == DBT_DEVICEARRIVAL ||
390
 
        wParam == DBT_DEVICEREMOVECOMPLETE) {
391
 
      DEV_BROADCAST_DEVICEINTERFACE* dbdi =
392
 
          reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(lParam);
393
 
      if (dbdi->dbcc_classguid == KSCATEGORY_AUDIO ||
394
 
        dbdi->dbcc_classguid == KSCATEGORY_VIDEO) {
395
 
        manager_->SignalDevicesChange();
396
 
      }
397
 
    }
398
 
    result = 0;
399
 
    return true;
400
 
  }
401
 
 
402
 
  return false;
403
 
}
404
 
 
405
 
};  // namespace cricket