diff options
Diffstat (limited to 'src/audio/manager.cpp')
| -rw-r--r-- | src/audio/manager.cpp | 481 |
1 files changed, 481 insertions, 0 deletions
diff --git a/src/audio/manager.cpp b/src/audio/manager.cpp new file mode 100644 index 0000000..618773d --- /dev/null +++ b/src/audio/manager.cpp @@ -0,0 +1,481 @@ +#ifdef WITH_VOICE +// clang-format off + +#ifdef _WIN32 + #include <winsock2.h> +#endif + +#include "manager.hpp" +#include <array> +#include <glibmm/main.h> +#include <spdlog/spdlog.h> +#define MINIAUDIO_IMPLEMENTATION +#include <miniaudio.h> +#include <opus.h> +#include <cstring> +// clang-format on + +const uint8_t *StripRTPExtensionHeader(const uint8_t *buf, int num_bytes, size_t &outlen) { + if (buf[0] == 0xbe && buf[1] == 0xde && num_bytes > 4) { + uint64_t offset = 4 + 4 * ((buf[2] << 8) | buf[3]); + + outlen = num_bytes - offset; + return buf + offset; + } + outlen = num_bytes; + return buf; +} + +void data_callback(ma_device *pDevice, void *pOutput, const void *pInput, ma_uint32 frameCount) { + AudioManager *mgr = reinterpret_cast<AudioManager *>(pDevice->pUserData); + if (mgr == nullptr) return; + std::lock_guard<std::mutex> _(mgr->m_mutex); + + auto *pOutputF32 = static_cast<float *>(pOutput); + for (auto &[ssrc, pair] : mgr->m_sources) { + double volume = 1.0; + if (const auto vol_it = mgr->m_volume_ssrc.find(ssrc); vol_it != mgr->m_volume_ssrc.end()) { + volume = vol_it->second; + } + auto &buf = pair.first; + const size_t n = std::min(static_cast<size_t>(buf.size()), static_cast<size_t>(frameCount * 2ULL)); + for (size_t i = 0; i < n; i++) { + pOutputF32[i] += volume * buf[i] / 32768.F; + } + buf.erase(buf.begin(), buf.begin() + n); + } +} + +void capture_data_callback(ma_device *pDevice, void *pOutput, const void *pInput, ma_uint32 frameCount) { + auto *mgr = reinterpret_cast<AudioManager *>(pDevice->pUserData); + if (mgr == nullptr) return; + + mgr->OnCapturedPCM(static_cast<const int16_t *>(pInput), frameCount); +} + +AudioManager::AudioManager() { + m_ok = true; + + int err; + m_encoder = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &err); + if (err != OPUS_OK) { + spdlog::get("audio")->error("failed to initialize opus encoder: {}", err); + m_ok = false; + return; + } + opus_encoder_ctl(m_encoder, OPUS_SET_BITRATE(64000)); + + if (ma_context_init(nullptr, 0, nullptr, &m_context) != MA_SUCCESS) { + spdlog::get("audio")->error("failed to initialize context"); + m_ok = false; + return; + } + + spdlog::get("audio")->info("Audio backend: {}", ma_get_backend_name(m_context.backend)); + + Enumerate(); + + m_playback_config = ma_device_config_init(ma_device_type_playback); + m_playback_config.playback.format = ma_format_f32; + m_playback_config.playback.channels = 2; + m_playback_config.sampleRate = 48000; + m_playback_config.dataCallback = data_callback; + m_playback_config.pUserData = this; + + if (const auto playback_id = m_devices.GetDefaultPlayback(); playback_id.has_value()) { + m_playback_id = *playback_id; + m_playback_config.playback.pDeviceID = &m_playback_id; + } + + if (ma_device_init(&m_context, &m_playback_config, &m_playback_device) != MA_SUCCESS) { + spdlog::get("audio")->error("failed to initialize playback device"); + m_ok = false; + return; + } + + if (ma_device_start(&m_playback_device) != MA_SUCCESS) { + spdlog::get("audio")->error("failed to start playback"); + ma_device_uninit(&m_playback_device); + m_ok = false; + return; + } + + m_capture_config = ma_device_config_init(ma_device_type_capture); + m_capture_config.capture.format = ma_format_s16; + m_capture_config.capture.channels = 2; + m_capture_config.sampleRate = 48000; + m_capture_config.periodSizeInFrames = 480; + m_capture_config.dataCallback = capture_data_callback; + m_capture_config.pUserData = this; + + if (const auto capture_id = m_devices.GetDefaultCapture(); capture_id.has_value()) { + m_capture_id = *capture_id; + m_capture_config.capture.pDeviceID = &m_capture_id; + } + + if (ma_device_init(&m_context, &m_capture_config, &m_capture_device) != MA_SUCCESS) { + spdlog::get("audio")->error("failed to initialize capture device"); + m_ok = false; + return; + } + + char playback_device_name[MA_MAX_DEVICE_NAME_LENGTH + 1]; + ma_device_get_name(&m_playback_device, ma_device_type_playback, playback_device_name, sizeof(playback_device_name), nullptr); + spdlog::get("audio")->info("using {} as playback device", playback_device_name); + + char capture_device_name[MA_MAX_DEVICE_NAME_LENGTH + 1]; + ma_device_get_name(&m_capture_device, ma_device_type_capture, capture_device_name, sizeof(capture_device_name), nullptr); + spdlog::get("audio")->info("using {} as capture device", capture_device_name); + + Glib::signal_timeout().connect(sigc::mem_fun(*this, &AudioManager::DecayVolumeMeters), 40); +} + +AudioManager::~AudioManager() { + ma_device_uninit(&m_playback_device); + ma_device_uninit(&m_capture_device); + ma_context_uninit(&m_context); + RemoveAllSSRCs(); +} + +void AudioManager::AddSSRC(uint32_t ssrc) { + std::lock_guard<std::mutex> _(m_mutex); + int error; + if (m_sources.find(ssrc) == m_sources.end()) { + auto *decoder = opus_decoder_create(48000, 2, &error); + m_sources.insert(std::make_pair(ssrc, std::make_pair(std::deque<int16_t> {}, decoder))); + } +} + +void AudioManager::RemoveSSRC(uint32_t ssrc) { + std::lock_guard<std::mutex> _(m_mutex); + if (auto it = m_sources.find(ssrc); it != m_sources.end()) { + opus_decoder_destroy(it->second.second); + m_sources.erase(it); + } +} + +void AudioManager::RemoveAllSSRCs() { + spdlog::get("audio")->info("removing all ssrc"); + std::lock_guard<std::mutex> _(m_mutex); + for (auto &[ssrc, pair] : m_sources) { + opus_decoder_destroy(pair.second); + } + m_sources.clear(); +} + +void AudioManager::SetOpusBuffer(uint8_t *ptr) { + m_opus_buffer = ptr; +} + +void AudioManager::FeedMeOpus(uint32_t ssrc, const std::vector<uint8_t> &data) { + if (!m_should_playback) return; + + std::lock_guard<std::mutex> _(m_mutex); + if (m_muted_ssrcs.find(ssrc) != m_muted_ssrcs.end()) return; + + size_t payload_size = 0; + const auto *opus_encoded = StripRTPExtensionHeader(data.data(), static_cast<int>(data.size()), payload_size); + static std::array<opus_int16, 120 * 48 * 2> pcm; + if (auto it = m_sources.find(ssrc); it != m_sources.end()) { + int decoded = opus_decode(it->second.second, opus_encoded, static_cast<opus_int32>(payload_size), pcm.data(), 120 * 48, 0); + if (decoded <= 0) { + } else { + UpdateReceiveVolume(ssrc, pcm.data(), decoded); + auto &buf = it->second.first; + buf.insert(buf.end(), pcm.begin(), pcm.begin() + decoded * 2); + } + } +} + +void AudioManager::StartCaptureDevice() { + if (ma_device_start(&m_capture_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to start capture device"); + } +} + +void AudioManager::StopCaptureDevice() { + if (ma_device_stop(&m_capture_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to stop capture device"); + } +} + +void AudioManager::SetPlaybackDevice(const Gtk::TreeModel::iterator &iter) { + spdlog::get("audio")->debug("Setting new playback device"); + + const auto device_id = m_devices.GetPlaybackDeviceIDFromModel(iter); + if (!device_id) { + spdlog::get("audio")->error("Requested ID from iterator is invalid"); + return; + } + + m_devices.SetActivePlaybackDevice(iter); + + m_playback_id = *device_id; + + ma_device_uninit(&m_playback_device); + + m_playback_config = ma_device_config_init(ma_device_type_playback); + m_playback_config.playback.format = ma_format_f32; + m_playback_config.playback.channels = 2; + m_playback_config.playback.pDeviceID = &m_playback_id; + m_playback_config.sampleRate = 48000; + m_playback_config.dataCallback = data_callback; + m_playback_config.pUserData = this; + + if (ma_device_init(&m_context, &m_playback_config, &m_playback_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to initialize new device"); + return; + } + + if (ma_device_start(&m_playback_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to start new device"); + return; + } +} + +void AudioManager::SetCaptureDevice(const Gtk::TreeModel::iterator &iter) { + spdlog::get("audio")->debug("Setting new capture device"); + + const auto device_id = m_devices.GetCaptureDeviceIDFromModel(iter); + if (!device_id) { + spdlog::get("audio")->error("Requested ID from iterator is invalid"); + return; + } + + m_devices.SetActiveCaptureDevice(iter); + + m_capture_id = *device_id; + + ma_device_uninit(&m_capture_device); + + m_capture_config = ma_device_config_init(ma_device_type_capture); + m_capture_config.capture.format = ma_format_s16; + m_capture_config.capture.channels = 2; + m_capture_config.capture.pDeviceID = &m_capture_id; + m_capture_config.sampleRate = 48000; + m_capture_config.periodSizeInFrames = 480; + m_capture_config.dataCallback = capture_data_callback; + m_capture_config.pUserData = this; + + if (ma_device_init(&m_context, &m_capture_config, &m_capture_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to initialize new device"); + return; + } + + // technically this should probably try and check old state but if you are in the window to change it then you are connected + if (ma_device_start(&m_capture_device) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to start new device"); + return; + } +} + +void AudioManager::SetCapture(bool capture) { + m_should_capture = capture; +} + +void AudioManager::SetPlayback(bool playback) { + m_should_playback = playback; +} + +void AudioManager::SetCaptureGate(double gate) { + m_capture_gate = gate; +} + +void AudioManager::SetCaptureGain(double gain) { + m_capture_gain = gain; +} + +double AudioManager::GetCaptureGate() const noexcept { + return m_capture_gate; +} + +double AudioManager::GetCaptureGain() const noexcept { + return m_capture_gain; +} + +void AudioManager::SetMuteSSRC(uint32_t ssrc, bool mute) { + std::lock_guard<std::mutex> _(m_mutex); + if (mute) { + m_muted_ssrcs.insert(ssrc); + } else { + m_muted_ssrcs.erase(ssrc); + } +} + +void AudioManager::SetVolumeSSRC(uint32_t ssrc, double volume) { + std::lock_guard<std::mutex> _(m_mutex); + m_volume_ssrc[ssrc] = volume; +} + +double AudioManager::GetVolumeSSRC(uint32_t ssrc) const { + std::lock_guard<std::mutex> _(m_mutex); + if (const auto iter = m_volume_ssrc.find(ssrc); iter != m_volume_ssrc.end()) { + return iter->second; + } + return 1.0; +} + +void AudioManager::SetEncodingApplication(int application) { + std::lock_guard<std::mutex> _(m_enc_mutex); + int prev_bitrate = 64000; + if (int err = opus_encoder_ctl(m_encoder, OPUS_GET_BITRATE(&prev_bitrate)); err != OPUS_OK) { + spdlog::get("audio")->error("Failed to get old bitrate when reinitializing: {}", err); + } + opus_encoder_destroy(m_encoder); + int err = 0; + m_encoder = opus_encoder_create(48000, 2, application, &err); + if (err != OPUS_OK) { + spdlog::get("audio")->critical("opus_encoder_create failed: {}", err); + return; + } + + if (int err = opus_encoder_ctl(m_encoder, OPUS_SET_BITRATE(prev_bitrate)); err != OPUS_OK) { + spdlog::get("audio")->error("Failed to set bitrate when reinitializing: {}", err); + } +} + +int AudioManager::GetEncodingApplication() { + std::lock_guard<std::mutex> _(m_enc_mutex); + int temp = OPUS_APPLICATION_VOIP; + if (int err = opus_encoder_ctl(m_encoder, OPUS_GET_APPLICATION(&temp)); err != OPUS_OK) { + spdlog::get("audio")->error("opus_encoder_ctl(OPUS_GET_APPLICATION) failed: {}", err); + } + return temp; +} + +void AudioManager::SetSignalHint(int signal) { + std::lock_guard<std::mutex> _(m_enc_mutex); + if (int err = opus_encoder_ctl(m_encoder, OPUS_SET_SIGNAL(signal)); err != OPUS_OK) { + spdlog::get("audio")->error("opus_encoder_ctl(OPUS_SET_SIGNAL) failed: {}", err); + } +} + +int AudioManager::GetSignalHint() { + std::lock_guard<std::mutex> _(m_enc_mutex); + int temp = OPUS_AUTO; + if (int err = opus_encoder_ctl(m_encoder, OPUS_GET_SIGNAL(&temp)); err != OPUS_OK) { + spdlog::get("audio")->error("opus_encoder_ctl(OPUS_GET_SIGNAL) failed: {}", err); + } + return temp; +} + +void AudioManager::SetBitrate(int bitrate) { + std::lock_guard<std::mutex> _(m_enc_mutex); + if (int err = opus_encoder_ctl(m_encoder, OPUS_SET_BITRATE(bitrate)); err != OPUS_OK) { + spdlog::get("audio")->error("opus_encoder_ctl(OPUS_SET_BITRATE) failed: {}", err); + } +} + +int AudioManager::GetBitrate() { + std::lock_guard<std::mutex> _(m_enc_mutex); + int temp = 64000; + if (int err = opus_encoder_ctl(m_encoder, OPUS_GET_BITRATE(&temp)); err != OPUS_OK) { + spdlog::get("audio")->error("opus_encoder_ctl(OPUS_GET_BITRATE) failed: {}", err); + } + return temp; +} + +void AudioManager::Enumerate() { + ma_device_info *pPlaybackDeviceInfo; + ma_uint32 playbackDeviceCount; + ma_device_info *pCaptureDeviceInfo; + ma_uint32 captureDeviceCount; + + spdlog::get("audio")->debug("Enumerating devices"); + + if (ma_context_get_devices( + &m_context, + &pPlaybackDeviceInfo, + &playbackDeviceCount, + &pCaptureDeviceInfo, + &captureDeviceCount) != MA_SUCCESS) { + spdlog::get("audio")->error("Failed to enumerate devices"); + return; + } + + spdlog::get("audio")->debug("Found {} playback devices and {} capture devices", playbackDeviceCount, captureDeviceCount); + + m_devices.SetDevices(pPlaybackDeviceInfo, playbackDeviceCount, pCaptureDeviceInfo, captureDeviceCount); +} + +void AudioManager::OnCapturedPCM(const int16_t *pcm, ma_uint32 frames) { + if (m_opus_buffer == nullptr || !m_should_capture) return; + + const double gain = m_capture_gain; + // i have a suspicion i can cast the const away... but i wont + std::vector<int16_t> new_pcm(pcm, pcm + frames * 2); + for (auto &val : new_pcm) { + const int32_t unclamped = static_cast<int32_t>(val * gain); + val = std::clamp(unclamped, INT16_MIN, INT16_MAX); + } + + UpdateCaptureVolume(new_pcm.data(), frames); + + if (m_capture_peak_meter / 32768.0 < m_capture_gate) return; + + m_enc_mutex.lock(); + int payload_len = opus_encode(m_encoder, new_pcm.data(), 480, static_cast<unsigned char *>(m_opus_buffer), 1275); + m_enc_mutex.unlock(); + if (payload_len < 0) { + spdlog::get("audio")->error("encoding error: {}", payload_len); + } else { + m_signal_opus_packet.emit(payload_len); + } +} + +void AudioManager::UpdateReceiveVolume(uint32_t ssrc, const int16_t *pcm, int frames) { + std::lock_guard<std::mutex> _(m_vol_mtx); + + auto &meter = m_volumes[ssrc]; + for (int i = 0; i < frames * 2; i += 2) { + const int amp = std::abs(pcm[i]); + meter = std::max(meter, std::abs(amp) / 32768.0); + } +} + +void AudioManager::UpdateCaptureVolume(const int16_t *pcm, ma_uint32 frames) { + for (ma_uint32 i = 0; i < frames * 2; i += 2) { + const int amp = std::abs(pcm[i]); + m_capture_peak_meter = std::max(m_capture_peak_meter.load(std::memory_order_relaxed), amp); + } +} + +bool AudioManager::DecayVolumeMeters() { + m_capture_peak_meter -= 600; + if (m_capture_peak_meter < 0) m_capture_peak_meter = 0; + + std::lock_guard<std::mutex> _(m_vol_mtx); + + for (auto &[ssrc, meter] : m_volumes) { + meter -= 0.01; + if (meter < 0.0) meter = 0.0; + } + + return true; +} + +bool AudioManager::OK() const { + return m_ok; +} + +double AudioManager::GetCaptureVolumeLevel() const noexcept { + return m_capture_peak_meter / 32768.0; +} + +double AudioManager::GetSSRCVolumeLevel(uint32_t ssrc) const noexcept { + std::lock_guard<std::mutex> _(m_vol_mtx); + if (const auto it = m_volumes.find(ssrc); it != m_volumes.end()) { + return it->second; + } + return 0.0; +} + +AudioDevices &AudioManager::GetDevices() { + return m_devices; +} + +AudioManager::type_signal_opus_packet AudioManager::signal_opus_packet() { + return m_signal_opus_packet; +} + +#endif |