mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2026-11-18 01:38:08 -06:00
400 lines
10 KiB
C++
400 lines
10 KiB
C++
// Copyright 2025 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "AudioCommon/Microphone.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <ranges>
|
|
#include <span>
|
|
|
|
#ifdef HAVE_CUBEB
|
|
#include <cubeb/cubeb.h>
|
|
|
|
#include "AudioCommon/CubebUtils.h"
|
|
#endif
|
|
|
|
#include "Common/Logging/Log.h"
|
|
#include "Common/MathUtil.h"
|
|
#include "Common/Swap.h"
|
|
#include "Core/Core.h"
|
|
#include "Core/System.h"
|
|
|
|
#ifdef _WIN32
|
|
#include <objbase.h>
|
|
#endif
|
|
|
|
#ifdef ANDROID
|
|
#include "jni/AndroidCommon/IDCache.h"
|
|
#endif
|
|
|
|
namespace AudioCommon
|
|
{
|
|
#ifdef HAVE_CUBEB
|
|
Microphone::Microphone(const MicrophoneState& sampler, std::string worker_name)
|
|
: m_sampler(sampler), m_worker(std::move(worker_name))
|
|
{
|
|
}
|
|
#else
|
|
Microphone::Microphone(const MicrophoneState& sampler, std::string worker_name) : m_sampler(sampler)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
Microphone::~Microphone()
|
|
{
|
|
StreamTerminate();
|
|
}
|
|
|
|
void Microphone::Initialize()
|
|
{
|
|
StreamInit();
|
|
}
|
|
|
|
#ifndef HAVE_CUBEB
|
|
void Microphone::StreamInit()
|
|
{
|
|
}
|
|
|
|
void Microphone::StreamStart(u32 /* sampling_rate */)
|
|
{
|
|
}
|
|
|
|
void Microphone::StreamStop()
|
|
{
|
|
}
|
|
|
|
void Microphone::StreamTerminate()
|
|
{
|
|
}
|
|
#else
|
|
void Microphone::StreamInit()
|
|
{
|
|
if (!m_worker.Execute([this] { m_cubeb_ctx = CubebUtils::GetContext(); }))
|
|
{
|
|
ERROR_LOG_FMT(AUDIO, "Failed to init microphone stream");
|
|
return;
|
|
}
|
|
|
|
// TODO: Not here but rather inside the WiiSpeak device if possible?
|
|
StreamStart(m_sampler.GetDefaultSamplingRate());
|
|
}
|
|
|
|
void Microphone::StreamTerminate()
|
|
{
|
|
StreamStop();
|
|
|
|
if (m_cubeb_ctx)
|
|
m_worker.Execute([this] { m_cubeb_ctx.reset(); });
|
|
}
|
|
|
|
static void StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state)
|
|
{
|
|
}
|
|
|
|
void Microphone::StreamStart(u32 sampling_rate)
|
|
{
|
|
if (!m_cubeb_ctx)
|
|
return;
|
|
|
|
m_worker.Execute([this, sampling_rate] {
|
|
#ifdef ANDROID
|
|
JNIEnv* env = IDCache::GetEnvForThread();
|
|
if (jboolean result = env->CallStaticBooleanMethod(
|
|
IDCache::GetPermissionHandlerClass(),
|
|
IDCache::GetPermissionHandlerHasRecordAudioPermission(), nullptr);
|
|
result == JNI_FALSE)
|
|
{
|
|
env->CallStaticVoidMethod(IDCache::GetPermissionHandlerClass(),
|
|
IDCache::GetPermissionHandlerRequestRecordAudioPermission(),
|
|
nullptr);
|
|
}
|
|
#endif
|
|
|
|
cubeb_stream_params params{};
|
|
params.format = CUBEB_SAMPLE_S16LE;
|
|
params.rate = sampling_rate;
|
|
params.channels = 1;
|
|
params.layout = CUBEB_LAYOUT_MONO;
|
|
|
|
std::lock_guard lock(m_ring_lock);
|
|
u32 minimum_latency;
|
|
if (cubeb_get_min_latency(m_cubeb_ctx.get(), ¶ms, &minimum_latency) != CUBEB_OK)
|
|
{
|
|
WARN_LOG_FMT(AUDIO, "Error getting minimum latency");
|
|
minimum_latency = 16;
|
|
}
|
|
|
|
cubeb_devid input_device = CubebUtils::GetInputDeviceById(GetInputDeviceId());
|
|
if (cubeb_stream_init(m_cubeb_ctx.get(), &m_cubeb_stream, GetCubebStreamName().c_str(),
|
|
input_device, ¶ms, nullptr, nullptr,
|
|
std::max<u32>(16, minimum_latency), CubebDataCallback, StateCallback,
|
|
this) != CUBEB_OK)
|
|
{
|
|
ERROR_LOG_FMT(AUDIO, "Error initializing cubeb stream");
|
|
return;
|
|
}
|
|
|
|
if (cubeb_stream_start(m_cubeb_stream) != CUBEB_OK)
|
|
{
|
|
ERROR_LOG_FMT(AUDIO, "Error starting cubeb stream");
|
|
return;
|
|
}
|
|
|
|
m_stream_buffer.resize(GetStreamSize());
|
|
m_stream_rpos = 0;
|
|
m_stream_wpos = 0;
|
|
INFO_LOG_FMT(AUDIO, "started cubeb stream");
|
|
});
|
|
}
|
|
|
|
void Microphone::StreamStop()
|
|
{
|
|
if (!m_cubeb_stream)
|
|
return;
|
|
|
|
m_worker.Execute([this] {
|
|
if (cubeb_stream_stop(m_cubeb_stream) != CUBEB_OK)
|
|
ERROR_LOG_FMT(AUDIO, "Error stopping cubeb stream");
|
|
cubeb_stream_destroy(m_cubeb_stream);
|
|
m_cubeb_stream = nullptr;
|
|
});
|
|
}
|
|
|
|
long Microphone::CubebDataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
|
|
void* /*output_buffer*/, long nframes)
|
|
{
|
|
// Skip data when core isn't running
|
|
if (Core::GetState(Core::System::GetInstance()) != Core::State::Running)
|
|
return nframes;
|
|
|
|
auto* mic = static_cast<Microphone*>(user_data);
|
|
|
|
// Skip data when HLE Wii Speak is muted
|
|
// TODO: Update cubeb and use cubeb_stream_set_input_mute
|
|
if (mic->IsMicrophoneMuted())
|
|
return nframes;
|
|
|
|
return mic->DataCallback(static_cast<const SampleType*>(input_buffer), nframes);
|
|
}
|
|
|
|
void Microphone::OnOverflow()
|
|
{
|
|
m_samples_avail = GetStreamSize();
|
|
}
|
|
|
|
long Microphone::DataCallback(const SampleType* input_buffer, long nframes)
|
|
{
|
|
std::lock_guard lock(m_ring_lock);
|
|
|
|
// Skip data if sampling is off or mute is on
|
|
if (!m_sampler.IsSampleOn() || m_sampler.IsMuted())
|
|
return nframes;
|
|
|
|
std::span<const SampleType> buffer(input_buffer, nframes);
|
|
const auto gain = ComputeGain(GetVolumeModifier());
|
|
const auto apply_gain = [gain](SampleType sample) {
|
|
return MathUtil::SaturatingCast<SampleType>(sample * gain);
|
|
};
|
|
|
|
const u32 stream_size = GetStreamSize();
|
|
const bool are_samples_byte_swapped = AreSamplesByteSwapped();
|
|
for (const SampleType le_sample : std::ranges::transform_view(buffer, apply_gain))
|
|
{
|
|
UpdateLoudness(le_sample);
|
|
m_stream_buffer[m_stream_wpos] =
|
|
are_samples_byte_swapped ? Common::swap16(le_sample) : le_sample;
|
|
m_stream_wpos = (m_stream_wpos + 1) % stream_size;
|
|
}
|
|
|
|
m_samples_avail += nframes;
|
|
if (m_samples_avail > stream_size)
|
|
{
|
|
OnOverflow();
|
|
}
|
|
|
|
return nframes;
|
|
}
|
|
#endif
|
|
|
|
u16 Microphone::ReadIntoBuffer(u8* ptr, u32 size)
|
|
{
|
|
const u32 samples_per_read = GetBufferSizeSamples();
|
|
const u32 bytes_per_read = samples_per_read * sizeof(SampleType);
|
|
|
|
std::lock_guard lock(m_ring_lock);
|
|
|
|
const u32 stream_size = GetStreamSize();
|
|
u8* const begin = ptr;
|
|
for (u8* const end = begin + size; ptr < end; ptr += bytes_per_read, size -= bytes_per_read)
|
|
{
|
|
if (size < bytes_per_read || m_samples_avail < samples_per_read)
|
|
break;
|
|
|
|
SampleType* last_buffer = &m_stream_buffer[m_stream_rpos];
|
|
std::memcpy(ptr, last_buffer, bytes_per_read);
|
|
|
|
m_samples_avail -= samples_per_read;
|
|
m_stream_rpos += samples_per_read;
|
|
m_stream_rpos %= stream_size;
|
|
}
|
|
return static_cast<u16>(ptr - begin);
|
|
}
|
|
|
|
u16 Microphone::GetLoudnessLevel() const
|
|
{
|
|
if (m_sampler.IsMuted() || IsMicrophoneMuted())
|
|
return 0;
|
|
return m_loudness_level;
|
|
}
|
|
|
|
// Based on graphical cues on Monster Hunter 3, the level seems properly displayed with values
|
|
// between 0 and 0x3a00.
|
|
//
|
|
// TODO: Proper hardware testing, documentation, formulas...
|
|
void Microphone::UpdateLoudness(const SampleType sample)
|
|
{
|
|
// Based on MH3 graphical cues, let's use a 0x4000 window
|
|
static const u32 WINDOW = 0x4000;
|
|
static const FloatType UNIT = (m_loudness.DB_MAX - m_loudness.DB_MIN) / WINDOW;
|
|
|
|
m_loudness.Update(sample);
|
|
|
|
if (m_loudness.samples_count >= m_loudness.SAMPLES_NEEDED)
|
|
{
|
|
const FloatType amp_db = m_loudness.GetAmplitudeDb();
|
|
m_loudness_level = static_cast<u16>((amp_db - m_loudness.DB_MIN) / UNIT);
|
|
|
|
#ifdef WII_SPEAK_LOG_STATS
|
|
m_loudness.LogStats();
|
|
#endif
|
|
|
|
m_loudness.Reset();
|
|
}
|
|
}
|
|
|
|
bool Microphone::HasData(u32 sample_count) const
|
|
{
|
|
std::lock_guard lock(m_ring_lock);
|
|
return m_samples_avail >= sample_count;
|
|
}
|
|
|
|
Microphone::FloatType Microphone::ComputeGain(FloatType relative_db) const
|
|
{
|
|
return m_loudness.ComputeGain(relative_db);
|
|
}
|
|
|
|
void Microphone::SetSamplingRate(u32 sampling_rate)
|
|
{
|
|
StreamStop();
|
|
StreamStart(sampling_rate);
|
|
}
|
|
|
|
u32 Microphone::GetBufferSizeSamples() const
|
|
{
|
|
return BUFF_SIZE_SAMPLES;
|
|
}
|
|
|
|
const Microphone::FloatType Microphone::Loudness::DB_MIN =
|
|
20 * std::log10(FloatType(1) / MAX_AMPLITUDE);
|
|
const Microphone::FloatType Microphone::Loudness::DB_MAX = 20 * std::log10(FloatType(1));
|
|
|
|
void Microphone::Loudness::Update(const SampleType sample)
|
|
{
|
|
++samples_count;
|
|
|
|
peak_min = std::min(sample, peak_min);
|
|
peak_max = std::max(sample, peak_max);
|
|
absolute_sum += std::abs(sample);
|
|
square_sum += std::pow(FloatType(sample), FloatType(2));
|
|
}
|
|
|
|
Microphone::SampleType Microphone::Loudness::GetPeak() const
|
|
{
|
|
return std::max(std::abs(peak_min), std::abs(peak_max));
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetDecibel(FloatType value)
|
|
{
|
|
return 20 * std::log10(value);
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetAmplitude() const
|
|
{
|
|
return GetPeak() / MAX_AMPLITUDE;
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetAmplitudeDb() const
|
|
{
|
|
return GetDecibel(GetAmplitude());
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetAbsoluteMean() const
|
|
{
|
|
return FloatType(absolute_sum) / samples_count;
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetAbsoluteMeanDb() const
|
|
{
|
|
return GetDecibel(GetAbsoluteMean());
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetRootMeanSquare() const
|
|
{
|
|
return std::sqrt(square_sum / samples_count);
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetRootMeanSquareDb() const
|
|
{
|
|
return GetDecibel(GetRootMeanSquare());
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetCrestFactor() const
|
|
{
|
|
const auto rms = GetRootMeanSquare();
|
|
if (rms == 0)
|
|
return FloatType(0);
|
|
return GetPeak() / rms;
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::GetCrestFactorDb() const
|
|
{
|
|
return GetDecibel(GetCrestFactor());
|
|
}
|
|
|
|
Microphone::FloatType Microphone::Loudness::ComputeGain(FloatType db)
|
|
{
|
|
return std::pow(FloatType(10), db / 20);
|
|
}
|
|
|
|
void Microphone::Loudness::Reset()
|
|
{
|
|
samples_count = 0;
|
|
absolute_sum = 0;
|
|
square_sum = FloatType(0);
|
|
peak_min = 0;
|
|
peak_max = 0;
|
|
}
|
|
|
|
void Microphone::Loudness::LogStats()
|
|
{
|
|
const auto amplitude = GetAmplitude();
|
|
const auto amplitude_db = GetDecibel(amplitude);
|
|
const auto rms = GetRootMeanSquare();
|
|
const auto rms_db = GetDecibel(rms);
|
|
const auto abs_mean = GetAbsoluteMean();
|
|
const auto abs_mean_db = GetDecibel(abs_mean);
|
|
const auto crest_factor = GetCrestFactor();
|
|
const auto crest_factor_db = GetDecibel(crest_factor);
|
|
|
|
INFO_LOG_FMT(AUDIO,
|
|
"Microphone loudness stats (sample count: {}/{}):\n"
|
|
" - min={} max={} amplitude={} ({} dB)\n"
|
|
" - rms={} ({} dB) \n"
|
|
" - abs_mean={} ({} dB)\n"
|
|
" - crest_factor={} ({} dB)",
|
|
samples_count, SAMPLES_NEEDED, peak_min, peak_max, amplitude, amplitude_db, rms,
|
|
rms_db, abs_mean, abs_mean_db, crest_factor, crest_factor_db);
|
|
}
|
|
} // namespace AudioCommon
|