platform_audio.h

/*
 * Copyright 2026 LiveKit
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "livekit/ffi_handle.h"
#include "livekit/visibility.h"
 
namespace livekit {
 
struct PlatformAudioState;
 
struct AudioDeviceInfo {
  std::uint32_t index = 0;
 
  std::string name;
 
  std::string id;
};
 
struct PlatformAudioOptions {
  bool echo_cancellation = true;
 
  bool noise_suppression = true;
 
  bool auto_gain_control = true;
 
  bool prefer_hardware = false;
};
 
class LIVEKIT_API PlatformAudioError : public std::runtime_error {
public:
  explicit PlatformAudioError(const std::string& message) : std::runtime_error(message) {}
};
 
class LIVEKIT_API PlatformAudioSource {
public:
  PlatformAudioSource(const PlatformAudioSource& other) = delete;
 
  PlatformAudioSource& operator=(const PlatformAudioSource& other) = delete;
 
  PlatformAudioSource(PlatformAudioSource&& other) noexcept = default;
 
  PlatformAudioSource& operator=(PlatformAudioSource&& other) noexcept = default;
 
  std::uint64_t ffiHandleId() const noexcept { return static_cast<std::uint64_t>(handle_.get()); }
 
private:
  friend class PlatformAudio;
 
  PlatformAudioSource(FfiHandle handle, std::shared_ptr<PlatformAudioState> platform_audio) noexcept;
 
  FfiHandle handle_;
  std::shared_ptr<PlatformAudioState> platform_audio_;
};
 
class LIVEKIT_API PlatformAudio {
public:
  PlatformAudio();
 
  PlatformAudio(const PlatformAudio& other) = default;
 
  PlatformAudio& operator=(const PlatformAudio& other) = default;
 
  PlatformAudio(PlatformAudio&& other) noexcept = default;
 
  PlatformAudio& operator=(PlatformAudio&& other) noexcept = default;
 
  std::int32_t recordingDeviceCount() const;
 
  std::int32_t playoutDeviceCount() const;
 
  std::vector<AudioDeviceInfo> recordingDevices() const;
 
  std::vector<AudioDeviceInfo> playoutDevices() const;
 
  void setRecordingDevice(const std::string& device_id) const;
 
  void setPlayoutDevice(const std::string& device_id) const;
 
  std::shared_ptr<PlatformAudioSource> createAudioSource(const PlatformAudioOptions& options = {}) const;
 
private:
  std::shared_ptr<PlatformAudioState> state_;
};
 
} // namespace livekit