media / audio / cras / cras_util.cc [blame]

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/audio/cras/cras_util.h"

#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/time/time.h"
#include "media/audio/audio_device_description.h"
#include "media/audio/cras/audio_manager_cras_base.h"
#include "media/base/media_switches.h"

namespace media {

namespace {

constexpr char kInternalInputVirtualDevice[] = "Built-in mic";
constexpr char kInternalOutputVirtualDevice[] = "Built-in speaker/headphone";
constexpr char kHeadphoneLineOutVirtualDevice[] = "Headphone/Line Out";

// Names below are from the node_type_to_str function in CRAS server.
// https://chromium.googlesource.com/chromiumos/third_party/adhd/+/refs/heads/main/cras/src/server/cras_iodev_list.c
constexpr char kInternalSpeaker[] = "INTERNAL_SPEAKER";
constexpr char kHeadphone[] = "HEADPHONE";
constexpr char kHDMI[] = "HDMI";
constexpr char kLineout[] = "LINEOUT";
constexpr char kMic[] = "MIC";
constexpr char kInternalMic[] = "INTERNAL_MIC";
constexpr char kFrontMic[] = "FRONT_MIC";
constexpr char kRearMic[] = "REAR_MIC";
constexpr char kBluetoothNBMic[] = "BLUETOOTH_NB_MIC";
constexpr char kUSB[] = "USB";
constexpr char kBluetooth[] = "BLUETOOTH";
constexpr char kAlsaLoopback[] = "ALSA_LOOPBACK";

// Returns if that an input or output audio device is for simple usage like
// playback or recording for user. In contrast, audio device such as loopback,
// always on keyword recognition (HOTWORD), and keyboard mic are not for simple
// usage.
// One special case is ALSA loopback device, which will only exist under
// testing. We want it visible to users for e2e tests.
bool IsForSimpleUsage(std::string type) {
  return type == kInternalSpeaker || type == kHeadphone || type == kHDMI ||
         type == kLineout || type == kMic || type == kInternalMic ||
         type == kFrontMic || type == kRearMic || type == kBluetoothNBMic ||
         type == kUSB || type == kBluetooth || type == kAlsaLoopback;
}

bool IsInternalMic(std::string type) {
  return type == kInternalMic || type == kFrontMic || type == kRearMic;
}

// Connects to the CRAS server.
libcras_client* CrasConnect() {
  libcras_client* client;

  client = libcras_client_create();
  if (!client) {
    LOG(ERROR) << "Couldn't create CRAS client.\n";
    return nullptr;
  }
  if (libcras_client_connect(client)) {
    LOG(ERROR) << "Couldn't connect CRAS client.\n";
    libcras_client_destroy(client);
    return nullptr;
  }
  return client;
}

// Disconnects from the CRAS server.
void CrasDisconnect(libcras_client** client) {
  if (*client) {
    libcras_client_stop(*client);
    libcras_client_destroy(*client);
    *client = nullptr;
  }
}

}  // namespace

CrasDevice::CrasDevice() = default;

CrasDevice::CrasDevice(struct libcras_node_info* node, DeviceType type)
    : type(type) {
  int rc;
  rc = libcras_node_info_get_id(node, &id);
  if (rc) {
    LOG(ERROR) << "Failed to get the node id: " << rc;
    id = 0;
  }

  rc = libcras_node_info_get_dev_idx(node, &dev_idx);
  if (rc) {
    LOG(ERROR) << "Failed to get the dev idx: " << rc;
    dev_idx = 0;
  }

  rc = libcras_node_info_is_plugged(node, &plugged);
  if (rc) {
    LOG(ERROR) << "Failed to get if the node is plugged: " << rc;
    plugged = false;
  }

  rc = libcras_node_info_is_active(node, &active);
  if (rc) {
    LOG(ERROR) << "Failed to get if the node is active: " << rc;
    active = false;
  }

  char* type_str;
  rc = libcras_node_info_get_type(node, &type_str);
  if (rc) {
    LOG(ERROR) << "Failed to get the node type: " << rc;
    node_type = nullptr;
  }
  node_type = type_str;

  char* node_name;
  rc = libcras_node_info_get_node_name(node, &node_name);
  if (rc) {
    LOG(ERROR) << "Failed to get the node name: " << rc;
    node_name = nullptr;
  }

  char* device_name;
  rc = libcras_node_info_get_dev_name(node, &device_name);
  if (rc) {
    LOG(ERROR) << "Failed to get the dev name: " << rc;
    device_name = nullptr;
  }

  rc = libcras_node_info_get_max_supported_channels(node,
                                                    &max_supported_channels);
  if (rc) {
    LOG(ERROR) << "Failed to get max supported channels: " << rc;
    max_supported_channels = 0;
  }

  name = std::string(node_name);
  if (name.empty() || name == "(default)") {
    name = device_name;
  }
  dev_name = device_name;
}

CrasDevice::CrasDevice(DeviceType type,
                       uint64_t id,
                       uint32_t dev_idx,
                       uint32_t max_supported_channels,
                       bool plugged,
                       bool active,
                       std::string node_type,
                       std::string name,
                       std::string dev_name)
    : type(type),
      id(id),
      dev_idx(dev_idx),
      max_supported_channels(max_supported_channels),
      plugged(plugged),
      active(active),
      node_type(node_type),
      name(name),
      dev_name(dev_name) {}

void mergeDevices(CrasDevice& old_dev, CrasDevice& new_dev) {
  if (old_dev.node_type == kLineout || new_dev.node_type == kLineout) {
    old_dev.name = kHeadphoneLineOutVirtualDevice;
    old_dev.node_type = "";
  } else if (old_dev.node_type == kInternalSpeaker ||
             new_dev.node_type == kInternalSpeaker) {
    old_dev.name = kInternalOutputVirtualDevice;
    old_dev.node_type = "";
  } else if (IsInternalMic(old_dev.node_type) ||
             IsInternalMic(new_dev.node_type)) {
    old_dev.name = kInternalInputVirtualDevice;
    old_dev.node_type = "";
  } else {
    LOG(WARNING) << "Failed to create virtual device for " << old_dev.name;
  }
  old_dev.active |= new_dev.active;
}

CrasUtil::CrasUtil() = default;

CrasUtil::~CrasUtil() = default;

bool CrasUtil::CacheEffects() {
  libcras_client* client = CrasConnect();
  if (!client) {
    LOG(ERROR) << "Failed to cache effects";
    return false;
  }
  if (libcras_client_get_aec_supported(client, &aec_supported_) < 0) {
    LOG(ERROR) << "Fail to query AEC supported";
    aec_supported_ = false;
  }
  if (libcras_client_get_agc_supported(client, &agc_supported_) < 0) {
    LOG(ERROR) << "Fail to query AGC supported";
    agc_supported_ = false;
  }
  if (libcras_client_get_ns_supported(client, &ns_supported_) < 0) {
    LOG(ERROR) << "Fail to query NS supported";
    ns_supported_ = false;
  }
  if (base::FeatureList::IsEnabled(media::kCrOSSystemVoiceIsolationOption)) {
    if (libcras_client_get_voice_isolation_supported(
            client, &voice_isolation_supported_) < 0) {
      LOG(ERROR) << "Fail to query VoiceIsolation supported";
      voice_isolation_supported_ = false;
    }
  }
  if (libcras_client_get_aec_group_id(client, &aec_group_id_) < 0) {
    LOG(ERROR) << "Fail to query AEC group ID";
    aec_group_id_ = -1;  // The default group ID is -1
  }
  if (libcras_client_get_default_output_buffer_size(
          client, &default_output_buffer_size_) < 0) {
    LOG(ERROR) << "Fail to query default output buffer size";
    default_output_buffer_size_ = 0;
  }
  CrasDisconnect(&client);
  return true;
}

std::vector<CrasDevice> CrasUtil::CrasGetAudioDevices(DeviceType type) {
  std::vector<CrasDevice> devices;

  libcras_client* client = CrasConnect();
  if (!client) {
    return devices;
  }

  int rc;

  struct libcras_node_info** nodes;
  size_t num_nodes;

  if (type == DeviceType::kInput) {
    rc =
        libcras_client_get_nodes(client, CRAS_STREAM_INPUT, &nodes, &num_nodes);
  } else {
    rc = libcras_client_get_nodes(client, CRAS_STREAM_OUTPUT, &nodes,
                                  &num_nodes);
  }

  if (rc < 0) {
    LOG(ERROR) << "Failed to get devices: " << std::strerror(rc);
    CrasDisconnect(&client);
    return devices;
  }

  for (size_t i = 0; i < num_nodes; i++) {
    auto new_dev = CrasDevice(nodes[i], type);
    if (!new_dev.plugged || !IsForSimpleUsage(new_dev.node_type)) {
      continue;
    }
    bool added = false;
    for (auto& dev : devices) {
      if (dev.dev_idx == new_dev.dev_idx) {
        mergeDevices(dev, new_dev);
        added = true;
        break;
      }
    }
    if (!added) {
      devices.emplace_back(new_dev);
    }
  }

  libcras_node_info_array_destroy(nodes, num_nodes);

  CrasDisconnect(&client);
  return devices;
}

int CrasUtil::CrasGetAecSupported() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return aec_supported_;
}

int CrasUtil::CrasGetAgcSupported() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return agc_supported_;
}

int CrasUtil::CrasGetNsSupported() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return ns_supported_;
}

int CrasUtil::CrasGetVoiceIsolationSupported() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return voice_isolation_supported_;
}

int CrasUtil::CrasGetAecGroupId() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return aec_group_id_;
}

int CrasUtil::CrasGetDefaultOutputBufferSize() {
  if (!cras_effects_cached_) {
    cras_effects_cached_ = CacheEffects();
  }
  return default_output_buffer_size_;
}

}  // namespace media