tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

device_info_pipewire.cc (3965B)


      1 /*
      2 *  Copyright (c) 2022 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 "modules/video_capture/linux/device_info_pipewire.h"
     12 
     13 #include <cstdint>
     14 #include <cstdlib>
     15 #include <cstring>
     16 
     17 #include "modules/video_capture/device_info_impl.h"
     18 #include "modules/video_capture/linux/pipewire_session.h"
     19 #include "modules/video_capture/video_capture_impl.h"
     20 #include "rtc_base/checks.h"
     21 #include "rtc_base/logging.h"
     22 
     23 namespace webrtc {
     24 namespace videocapturemodule {
     25 DeviceInfoPipeWire::DeviceInfoPipeWire(VideoCaptureOptions* options)
     26    : DeviceInfoImpl(), pipewire_session_(options->pipewire_session()) {
     27  const bool ret = pipewire_session_->RegisterDeviceInfo(this);
     28  RTC_CHECK(ret);
     29 }
     30 
     31 int32_t DeviceInfoPipeWire::Init() {
     32  return 0;
     33 }
     34 
     35 DeviceInfoPipeWire::~DeviceInfoPipeWire() {
     36  const bool ret = pipewire_session_->DeRegisterDeviceInfo(this);
     37  RTC_CHECK(ret);
     38 }
     39 
     40 uint32_t DeviceInfoPipeWire::NumberOfDevices() {
     41  RTC_CHECK(pipewire_session_);
     42 
     43  return pipewire_session_->nodes().size();
     44 }
     45 
     46 int32_t DeviceInfoPipeWire::GetDeviceName(uint32_t deviceNumber,
     47                                          char* deviceNameUTF8,
     48                                          uint32_t deviceNameLength,
     49                                          char* deviceUniqueIdUTF8,
     50                                          uint32_t deviceUniqueIdUTF8Length,
     51                                          char* productUniqueIdUTF8,
     52                                          uint32_t productUniqueIdUTF8Length,
     53                                          pid_t* pid,
     54                                          bool* deviceIsPlaceholder) {
     55  RTC_CHECK(pipewire_session_);
     56 
     57  if (deviceNumber >= NumberOfDevices())
     58    return -1;
     59 
     60  const auto& node = pipewire_session_->nodes().at(deviceNumber);
     61 
     62  if (deviceNameLength <= node->display_name().length()) {
     63    RTC_LOG(LS_INFO) << "deviceNameUTF8 buffer passed is too small";
     64    return -1;
     65  }
     66  if (deviceUniqueIdUTF8Length <= node->unique_id().length()) {
     67    RTC_LOG(LS_INFO) << "deviceUniqueIdUTF8 buffer passed is too small";
     68    return -1;
     69  }
     70  if (productUniqueIdUTF8 &&
     71      productUniqueIdUTF8Length <= node->model_id().length()) {
     72    RTC_LOG(LS_INFO) << "productUniqueIdUTF8 buffer passed is too small";
     73    return -1;
     74  }
     75 
     76  memset(deviceNameUTF8, 0, deviceNameLength);
     77  node->display_name().copy(deviceNameUTF8, deviceNameLength);
     78 
     79  memset(deviceUniqueIdUTF8, 0, deviceUniqueIdUTF8Length);
     80  node->unique_id().copy(deviceUniqueIdUTF8, deviceUniqueIdUTF8Length);
     81 
     82  if (productUniqueIdUTF8) {
     83    memset(productUniqueIdUTF8, 0, productUniqueIdUTF8Length);
     84    node->model_id().copy(productUniqueIdUTF8, productUniqueIdUTF8Length);
     85  }
     86 
     87  return 0;
     88 }
     89 
     90 int32_t DeviceInfoPipeWire::CreateCapabilityMap(
     91    const char* deviceUniqueIdUTF8) {
     92  RTC_CHECK(pipewire_session_);
     93 
     94  for (auto& node : pipewire_session_->nodes()) {
     95    if (node->unique_id().compare(deviceUniqueIdUTF8) != 0)
     96      continue;
     97 
     98    _captureCapabilities = node->capabilities();
     99    _lastUsedDeviceNameLength = node->unique_id().length();
    100    _lastUsedDeviceName = static_cast<char*>(
    101        realloc(_lastUsedDeviceName, _lastUsedDeviceNameLength + 1));
    102    memcpy(_lastUsedDeviceName, deviceUniqueIdUTF8,
    103           _lastUsedDeviceNameLength + 1);
    104    return _captureCapabilities.size();
    105  }
    106  return -1;
    107 }
    108 
    109 int32_t DeviceInfoPipeWire::DisplayCaptureSettingsDialogBox(
    110    const char* /*deviceUniqueIdUTF8*/,
    111    const char* /*dialogTitleUTF8*/,
    112    void* /*parentWindow*/,
    113    uint32_t /*positionX*/,
    114    uint32_t /*positionY*/) {
    115  return -1;
    116 }
    117 
    118 }  // namespace videocapturemodule
    119 }  // namespace webrtc