OpenPunk/citra
1
0
Fork 0
mirror of https://github.com/citra-emu/citra.git synced 2024-12-18 12:30:04 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #4671 from jroweboy/mic4

Browse Source 
Microphone support
This commit is contained in:
Vamsi Krishna 2019-03-20 23:12:38 +05:30 committed by GitHub
commit aedf5a84b0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 714 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/audio_core/CMakeLists.txt
View File

@ -30,7 +30,7 @@ add_library(audio_core STATIC
time_stretch.h
$<$<BOOL:${SDL2_FOUND}>:sdl2_sink.cpp sdl2_sink.h>
$<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
$<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h cubeb_input.cpp cubeb_input.h>
$<$<BOOL:${FFMPEG_FOUND}>:hle/ffmpeg_decoder.cpp hle/ffmpeg_decoder.h hle/ffmpeg_dl.cpp hle/ffmpeg_dl.h>
$<$<BOOL:${ENABLE_MF}>:hle/wmf_decoder.cpp hle/wmf_decoder.h hle/wmf_decoder_utils.cpp hle/wmf_decoder_utils.h>
)
@ -61,6 +61,6 @@ endif()
if(ENABLE_CUBEB)
target_link_libraries(audio_core PRIVATE cubeb)
add_definitions(-DHAVE_CUBEB=1)
target_compile_definitions(audio_core PUBLIC HAVE_CUBEB)
endif()

165
src/audio_core/cubeb_input.cpp Normal file
View File

@ -0,0 +1,165 @@
// Copyright 2018 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <vector>
#include <cubeb/cubeb.h>
#include "audio_core/cubeb_input.h"
#include "common/logging/log.h"
namespace AudioCore {
using SampleQueue = Common::SPSCQueue<Frontend::Mic::Samples>;
struct CubebInput::Impl {
cubeb* ctx = nullptr;
cubeb_stream* stream = nullptr;
std::unique_ptr<SampleQueue> sample_queue{};
u8 sample_size_in_bytes = 0;
static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
void* output_buffer, long num_frames);
static void StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state);
};
CubebInput::CubebInput() : impl(std::make_unique<Impl>()) {
if (cubeb_init(&impl->ctx, "Citra Input", nullptr) != CUBEB_OK) {
LOG_ERROR(Audio, "cubeb_init failed! Mic will not work properly");
return;
}
impl->sample_queue = std::make_unique<SampleQueue>();
}
CubebInput::~CubebInput() {
if (!impl->ctx)
return;
if (cubeb_stream_stop(impl->stream) != CUBEB_OK) {
LOG_ERROR(Audio, "Error stopping cubeb input stream.");
}
cubeb_destroy(impl->ctx);
}
void CubebInput::StartSampling(const Frontend::Mic::Parameters& params) {
// Cubeb apparently only supports signed 16 bit PCM (and float32 which the 3ds doesn't support)
// TODO resample the input stream
if (params.sign == Frontend::Mic::Signedness::Unsigned) {
LOG_ERROR(Audio,
"Application requested unsupported unsigned pcm format. Falling back to signed");
}
impl->sample_size_in_bytes = params.sample_size / 8;
parameters = params;
is_sampling = true;
cubeb_devid input_device = nullptr;
cubeb_stream_params input_params;
input_params.channels = 1;
input_params.layout = CUBEB_LAYOUT_UNDEFINED;
input_params.prefs = CUBEB_STREAM_PREF_NONE;
input_params.format = CUBEB_SAMPLE_S16LE;
input_params.rate = params.sample_rate;
u32 latency_frames;
if (cubeb_get_min_latency(impl->ctx, &input_params, &latency_frames) != CUBEB_OK) {
LOG_ERROR(Audio, "Could not get minimum latency");
}
if (cubeb_stream_init(impl->ctx, &impl->stream, "Citra Microphone", input_device, &input_params,
nullptr, nullptr, latency_frames, Impl::DataCallback, Impl::StateCallback,
impl.get()) != CUBEB_OK) {
LOG_CRITICAL(Audio, "Error creating cubeb input stream");
is_sampling = false;
return;
}
if (cubeb_stream_start(impl->stream) != CUBEB_OK) {
LOG_CRITICAL(Audio, "Error starting cubeb input stream");
is_sampling = false;
return;
}
}
void CubebInput::StopSampling() {
if (impl->stream) {
cubeb_stream_stop(impl->stream);
}
is_sampling = false;
}
void CubebInput::AdjustSampleRate(u32 sample_rate) {
// TODO This should restart the stream with the new sample rate
LOG_ERROR(Audio, "AdjustSampleRate unimplemented!");
}
Frontend::Mic::Samples CubebInput::Read() {
Frontend::Mic::Samples samples{};
Frontend::Mic::Samples queue;
while (impl->sample_queue->Pop(queue)) {
samples.insert(samples.end(), queue.begin(), queue.end());
}
return samples;
}
long CubebInput::Impl::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
void* output_buffer, long num_frames) {
Impl* impl = static_cast<Impl*>(user_data);
if (!impl) {
return 0;
}
constexpr auto resample_s16_s8 = [](s16 sample) {
return static_cast<u8>(static_cast<u16>(sample) >> 8);
};
std::vector<u8> samples{};
samples.reserve(num_frames * impl->sample_size_in_bytes);
if (impl->sample_size_in_bytes == 1) {
// If the sample format is 8bit, then resample back to 8bit before passing back to core
for (std::size_t i; i < num_frames; i++) {
s16 data;
std::memcpy(&data, static_cast<const u8*>(input_buffer) + i * 2, 2);
samples.push_back(resample_s16_s8(data));
}
} else {
// Otherwise copy all of the samples to the buffer (which will be treated as s16 by core)
const u8* data = reinterpret_cast<const u8*>(input_buffer);
samples.insert(samples.begin(), data, data + num_frames * impl->sample_size_in_bytes);
}
impl->sample_queue->Push(samples);
// returning less than num_frames here signals cubeb to stop sampling
return num_frames;
}
void CubebInput::Impl::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
std::vector<std::string> ListCubebInputDevices() {
std::vector<std::string> device_list;
cubeb* ctx;
if (cubeb_init(&ctx, "Citra Input Device Enumerator", nullptr) != CUBEB_OK) {
LOG_CRITICAL(Audio, "cubeb_init failed");
return {};
}
cubeb_device_collection collection;
if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_INPUT, &collection) != CUBEB_OK) {
LOG_WARNING(Audio_Sink, "Audio input device enumeration not supported");
} else {
for (std::size_t i = 0; i < collection.count; i++) {
const cubeb_device_info& device = collection.device[i];
if (device.state == CUBEB_DEVICE_STATE_ENABLED && device.friendly_name) {
device_list.emplace_back(device.friendly_name);
}
}
cubeb_device_collection_destroy(ctx, &collection);
}
cubeb_destroy(ctx);
return device_list;
}
} // namespace AudioCore

33
src/audio_core/cubeb_input.h Normal file
View File

@ -0,0 +1,33 @@
// Copyright 2018 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <memory>
#include <vector>
#include "core/frontend/mic.h"
namespace AudioCore {
class CubebInput final : public Frontend::Mic::Interface {
public:
CubebInput();
~CubebInput() override;
void StartSampling(const Frontend::Mic::Parameters& params) override;
void StopSampling() override;
void AdjustSampleRate(u32 sample_rate) override;
Frontend::Mic::Samples Read() override;
private:
struct Impl;
std::unique_ptr<Impl> impl;
};
std::vector<std::string> ListCubebInputDevices();
} // namespace AudioCore

4
src/audio_core/cubeb_sink.cpp
View File

@ -27,7 +27,7 @@ struct CubebSink::Impl {
};
CubebSink::CubebSink(std::string_view target_device_name) : impl(std::make_unique<Impl>()) {
if (cubeb_init(&impl->ctx, "Citra", nullptr) != CUBEB_OK) {
if (cubeb_init(&impl->ctx, "Citra Output", nullptr) != CUBEB_OK) {
LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
return;
}
@ -179,7 +179,7 @@ std::vector<std::string> ListCubebSinkDevices() {
} else {
for (std::size_t i = 0; i < collection.count; i++) {
const cubeb_device_info& device = collection.device[i];
if (device.friendly_name) {
if (device.state == CUBEB_DEVICE_STATE_ENABLED && device.friendly_name) {
device_list.emplace_back(device.friendly_name);
}
}

4
src/citra/config.cpp
View File

@ -166,6 +166,10 @@ void Config::ReadValues() {
sdl2_config->GetBoolean("Audio", "enable_audio_stretching", true);
Settings::values.audio_device_id = sdl2_config->GetString("Audio", "output_device", "auto");
Settings::values.volume = sdl2_config->GetReal("Audio", "volume", 1);
Settings::values.mic_input_device =
sdl2_config->GetString("Audio", "mic_input_device", "Default");
Settings::values.mic_input_type =
static_cast<Settings::MicInputType>(sdl2_config->GetInteger("Audio", "mic_input_type", 0));
// Data Storage
Settings::values.use_virtual_sd =

7
src/citra_qt/configuration/config.cpp
View File

@ -198,6 +198,10 @@ void Config::ReadValues() {
Settings::values.audio_device_id =
ReadSetting("output_device", "auto").toString().toStdString();
Settings::values.volume = ReadSetting("volume", 1).toFloat();
Settings::values.mic_input_type =
static_cast<Settings::MicInputType>(ReadSetting("mic_input_type", 0).toInt());
Settings::values.mic_input_device =
ReadSetting("mic_input_device", "Default").toString().toStdString();
qt_config->endGroup();
using namespace Service::CAM;
@ -480,6 +484,9 @@ void Config::SaveValues() {
WriteSetting("enable_audio_stretching", Settings::values.enable_audio_stretching, true);
WriteSetting("output_device", QString::fromStdString(Settings::values.audio_device_id), "auto");
WriteSetting("volume", Settings::values.volume, 1.0f);
WriteSetting("mic_input_device", QString::fromStdString(Settings::values.mic_input_device),
"Default");
WriteSetting("mic_input_type", static_cast<int>(Settings::values.mic_input_type), 0);
qt_config->endGroup();
using namespace Service::CAM;

34
src/citra_qt/configuration/configure_audio.cpp
View File

@ -3,6 +3,10 @@
// Refer to the license.txt file included.
#include <memory>
#include <QtGlobal>
#ifdef HAVE_CUBEB
#include "audio_core/cubeb_input.h"
#endif
#include "audio_core/sink.h"
#include "audio_core/sink_details.h"
#include "citra_qt/configuration/configure_audio.h"
@ -28,10 +32,19 @@ ConfigureAudio::ConfigureAudio(QWidget* parent)
connect(ui->volume_slider, &QSlider::valueChanged, this,
&ConfigureAudio::setVolumeIndicatorText);
ui->input_device_combo_box->clear();
ui->input_device_combo_box->addItem(tr("Default"));
#ifdef HAVE_CUBEB
for (const auto& device : AudioCore::ListCubebInputDevices()) {
ui->input_device_combo_box->addItem(QString::fromStdString(device));
}
#endif
connect(ui->input_type_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
&ConfigureAudio::updateAudioInputDevices);
this->setConfiguration();
connect(ui->output_sink_combo_box,
static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
&ConfigureAudio::updateAudioDevices);
connect(ui->output_sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
&ConfigureAudio::updateAudioOutputDevices);
}
ConfigureAudio::~ConfigureAudio() {}
@ -40,7 +53,7 @@ void ConfigureAudio::setConfiguration() {
setOutputSinkFromSinkID();
// The device list cannot be pre-populated (nor listed) until the output sink is known.
updateAudioDevices(ui->output_sink_combo_box->currentIndex());
updateAudioOutputDevices(ui->output_sink_combo_box->currentIndex());
setAudioDeviceFromDeviceID();
@ -59,6 +72,12 @@ void ConfigureAudio::setConfiguration() {
selection = 0;
}
ui->emulation_combo_box->setCurrentIndex(selection);
int index = static_cast<int>(Settings::values.mic_input_type);
ui->input_type_combo_box->setCurrentIndex(index);
ui->input_device_combo_box->setCurrentText(
QString::fromStdString(Settings::values.mic_input_device));
updateAudioInputDevices(index);
}
void ConfigureAudio::setOutputSinkFromSinkID() {
@ -105,9 +124,12 @@ void ConfigureAudio::applyConfiguration() {
static_cast<float>(ui->volume_slider->sliderPosition()) / ui->volume_slider->maximum();
Settings::values.enable_dsp_lle = ui->emulation_combo_box->currentIndex() != 0;
Settings::values.enable_dsp_lle_multithread = ui->emulation_combo_box->currentIndex() == 2;
Settings::values.mic_input_type =
static_cast<Settings::MicInputType>(ui->input_type_combo_box->currentIndex());
Settings::values.mic_input_device = ui->input_device_combo_box->currentText().toStdString();
}
void ConfigureAudio::updateAudioDevices(int sink_index) {
void ConfigureAudio::updateAudioOutputDevices(int sink_index) {
ui->audio_device_combo_box->clear();
ui->audio_device_combo_box->addItem(AudioCore::auto_device_name);
@ -117,6 +139,8 @@ void ConfigureAudio::updateAudioDevices(int sink_index) {
}
}
void ConfigureAudio::updateAudioInputDevices(int index) {}
void ConfigureAudio::retranslateUi() {
ui->retranslateUi(this);
}

3
src/citra_qt/configuration/configure_audio.h
View File

@ -23,7 +23,8 @@ public:
void setConfiguration();
private:
void updateAudioDevices(int sink_index);
void updateAudioOutputDevices(int sink_index);
void updateAudioInputDevices(int index);
void setOutputSinkFromSinkID();
void setAudioDeviceFromDeviceID();

61
src/citra_qt/configuration/configure_audio.ui
View File

@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>188</width>
<height>246</height>
<width>329</width>
<height>332</height>
</rect>
</property>
<layout class="QVBoxLayout">
@ -39,7 +39,7 @@
<item>
<widget class="QLabel" name="label1">
<property name="text">
<string>Output Engine:</string>
<string>Output Engine</string>
</property>
</widget>
</item>
@ -63,7 +63,7 @@
<item>
<widget class="QLabel" name="label2">
<property name="text">
<string>Audio Device:</string>
<string>Audio Device</string>
</property>
</widget>
</item>
@ -137,6 +137,59 @@
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Microphone</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>Input Type</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="input_type_combo_box">
<item>
<property name="text">
<string>None</string>
</property>
</item>
<item>
<property name="text">
<string>Real Device</string>
</property>
</item>
<item>
<property name="text">
<string>Static Noise</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>Input Device</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="input_device_combo_box"/>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<spacer>
<property name="orientation">

2
src/core/CMakeLists.txt
View File

@ -97,6 +97,8 @@ add_library(core STATIC
frontend/framebuffer_layout.cpp
frontend/framebuffer_layout.h
frontend/input.h
frontend/mic.h
frontend/mic.cpp
gdbstub/gdbstub.cpp
gdbstub/gdbstub.h
hle/applets/applet.cpp

60
src/core/frontend/mic.cpp Normal file
View File

@ -0,0 +1,60 @@
// Copyright 2019 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <array>
#include "core/frontend/mic.h"
namespace Frontend::Mic {
constexpr std::array<u8, 16> NOISE_SAMPLE_8_BIT = {0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0x8E, 0xFF};
constexpr std::array<u8, 32> NOISE_SAMPLE_16_BIT = {
0x64, 0x61, 0x74, 0x61, 0x56, 0xD7, 0x00, 0x00, 0x48, 0xF7, 0x86, 0x05, 0x77, 0x1A, 0xF4, 0x1F,
0x28, 0x0F, 0x6B, 0xEB, 0x1C, 0xC0, 0xCB, 0x9D, 0x46, 0x90, 0xDF, 0x98, 0xEA, 0xAE, 0xB5, 0xC4};
Interface::~Interface() = default;
void NullMic::StartSampling(const Parameters& params) {
parameters = params;
is_sampling = true;
}
void NullMic::StopSampling() {
is_sampling = false;
}
void NullMic::AdjustSampleRate(u32 sample_rate) {
parameters.sample_rate = sample_rate;
}
Samples NullMic::Read() {
return {};
}
StaticMic::StaticMic()
: CACHE_8_BIT{NOISE_SAMPLE_8_BIT.begin(), NOISE_SAMPLE_8_BIT.end()},
CACHE_16_BIT{NOISE_SAMPLE_16_BIT.begin(), NOISE_SAMPLE_16_BIT.end()} {}
StaticMic::~StaticMic() = default;
void StaticMic::StartSampling(const Parameters& params) {
sample_rate = params.sample_rate;
sample_size = params.sample_size;
parameters = params;
is_sampling = true;
}
void StaticMic::StopSampling() {
is_sampling = false;
}
void StaticMic::AdjustSampleRate(u32 sample_rate) {}
Samples StaticMic::Read() {
return (sample_size == 8) ? CACHE_8_BIT : CACHE_16_BIT;
}
} // namespace Frontend::Mic

116
src/core/frontend/mic.h Normal file
View File

@ -0,0 +1,116 @@
// Copyright 2019 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <memory>
#include <vector>
#include "common/swap.h"
#include "common/threadsafe_queue.h"
namespace Frontend::Mic {
enum class Signedness : u8 {
Signed,
Unsigned,
};
using Samples = std::vector<u8>;
struct Parameters {
Signedness sign;
u8 sample_size;
bool buffer_loop;
u32 sample_rate;
u32 buffer_offset;
u32 buffer_size;
};
class Interface {
public:
Interface() = default;
virtual ~Interface();
/// Starts the microphone. Called by Core
virtual void StartSampling(const Parameters& params) = 0;
/// Stops the microphone. Called by Core
virtual void StopSampling() = 0;
/**
* Called from the actual event timing at a constant period under a given sample rate.
* When sampling is enabled this function is expected to return a buffer of 16 samples in ideal
* conditions, but can be lax if the data is coming in from another source like a real mic.
*/
virtual Samples Read() = 0;
/**
* Adjusts the Parameters. Implementations should update the parameters field in addition to
* changing the mic to sample according to the new parameters. Called by Core
*/
virtual void AdjustSampleRate(u32 sample_rate) = 0;
/// Value from 0 - 100 to adjust the mic gain setting. Called by Core
virtual void SetGain(u8 mic_gain) {
gain = mic_gain;
}
u8 GetGain() const {
return gain;
}
void SetPower(bool power) {
powered = power;
}
bool GetPower() const {
return powered;
}
bool IsSampling() const {
return is_sampling;
}
const Parameters& GetParameters() const {
return parameters;
}
protected:
Parameters parameters;
u8 gain = 0;
bool is_sampling = false;
bool powered = false;
};
class NullMic final : public Interface {
public:
void StartSampling(const Parameters& params) override;
void StopSampling() override;
void AdjustSampleRate(u32 sample_rate) override;
Samples Read() override;
};
class StaticMic final : public Interface {
public:
StaticMic();
~StaticMic() override;
void StartSampling(const Parameters& params) override;
void StopSampling() override;
void AdjustSampleRate(u32 sample_rate) override;
Samples Read() override;
private:
u16 sample_rate = 0;
u8 sample_size = 0;
std::vector<u8> CACHE_8_BIT;
std::vector<u8> CACHE_16_BIT;
};
} // namespace Frontend::Mic

258
src/core/hle/service/mic_u.cpp
View File

@ -2,8 +2,12 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#ifdef HAVE_CUBEB
#include "audio_core/cubeb_input.h"
#endif
#include "common/logging/log.h"
#include "core/core.h"
#include "core/frontend/mic.h"
#include "core/hle/ipc.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/kernel/event.h"
@ -11,27 +15,96 @@
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/shared_memory.h"
#include "core/hle/service/mic_u.h"
#include "core/settings.h"
namespace Service::MIC {
/// Microphone audio encodings.
enum class Encoding : u8 {
PCM8 = 0,
PCM16 = 1,
PCM8Signed = 2,
PCM16Signed = 3,
PCM8 = 0, ///< Unsigned 8-bit PCM.
PCM16 = 1, ///< Unsigned 16-bit PCM.
PCM8Signed = 2, ///< Signed 8-bit PCM.
PCM16Signed = 3, ///< Signed 16-bit PCM.
};
/// Microphone audio sampling rates. The actual accurate sampling rate can be calculated using
/// (16756991 / 512) / (SampleRate + 1) where SampleRate is one of the above values.
enum class SampleRate : u8 {
SampleRate32730 = 0,
SampleRate16360 = 1,
SampleRate10910 = 2,
SampleRate8180 = 3
Rate32730 = 0, ///< 32728.498 Hz
Rate16360 = 1, ///< 16364.479 Hz
Rate10910 = 2, ///< 10909.499 Hz
Rate8180 = 3 ///< 8182.1245 Hz
};
constexpr u32 GetSampleRateInHz(SampleRate sample_rate) {
switch (sample_rate) {
case SampleRate::Rate8180:
return 8182;
case SampleRate::Rate10910:
return 10909;
case SampleRate::Rate16360:
return 16364;
case SampleRate::Rate32730:
return 32728;
default:
UNREACHABLE();
}
}
// The 3ds hardware was tested to write to the sharedmem every 15 samples regardless of sample_rate.
// So we can just divide the sample rate by 16 and that'll give the correct timing for the event
constexpr u64 GetBufferUpdateRate(SampleRate sample_rate) {
return GetSampleRateInHz(sample_rate) / 16;
}
// Variables holding the current mic buffer writing state
struct State {
u8* sharedmem_buffer = nullptr;
u32 sharedmem_size = 0;
std::size_t size = 0;
u32 offset = 0;
u32 initial_offset = 0;
bool looped_buffer = false;
u8 sample_size = 0;
SampleRate sample_rate = SampleRate::Rate16360;
void WriteSamples(const std::vector<u8>& samples) {
u32 bytes_total_written = 0;
const std::size_t remaining_space = size - offset;
std::size_t bytes_to_write = std::min(samples.size(), remaining_space);
// Write as many samples as we can to the buffer.
// TODO if the sample size is 16bit, this could theoretically cut a sample in the case where
// the application configures an odd size
std::memcpy(sharedmem_buffer + offset, samples.data(), bytes_to_write);
offset += static_cast<u32>(bytes_to_write);
bytes_total_written += static_cast<u32>(bytes_to_write);
// If theres any samples left to write after we looped, go ahead and write them now
if (looped_buffer && samples.size() > bytes_total_written) {
offset = initial_offset;
bytes_to_write = std::min(samples.size() - bytes_total_written, size);
std::memcpy(sharedmem_buffer + offset, samples.data() + bytes_total_written,
bytes_to_write);
offset += static_cast<u32>(bytes_to_write);
}
// The last 4 bytes of the shared memory contains the latest offset
// so update that as well https://www.3dbrew.org/wiki/MIC_Shared_Memory
u32_le off = offset;
std::memcpy(sharedmem_buffer + (sharedmem_size - sizeof(u32)), reinterpret_cast<u8*>(&off),
sizeof(u32));
}
};
struct MIC_U::Impl {
explicit Impl(Core::System& system) {
explicit Impl(Core::System& system) : timing(system.CoreTiming()) {
buffer_full_event =
system.Kernel().CreateEvent(Kernel::ResetType::OneShot, "MIC_U::buffer_full_event");
buffer_write_event =
timing.RegisterEvent("MIC_U::UpdateBuffer", [this](u64 userdata, s64 cycles_late) {
UpdateSharedMemBuffer(userdata, cycles_late);
});
}
void MapSharedMem(Kernel::HLERequestContext& ctx) {
@ -41,12 +114,14 @@ struct MIC_U::Impl {
if (shared_memory) {
shared_memory->SetName("MIC_U:shared_memory");
state.sharedmem_buffer = shared_memory->GetPointer();
state.sharedmem_size = size;
}
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_MIC, "called, size=0x{:X}", size);
LOG_TRACE(Service_MIC, "called, size=0x{:X}", size);
}
void UnmapSharedMem(Kernel::HLERequestContext& ctx) {
@ -54,23 +129,63 @@ struct MIC_U::Impl {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
shared_memory = nullptr;
rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_MIC, "called");
LOG_TRACE(Service_MIC, "called");
}
void UpdateSharedMemBuffer(u64 userdata, s64 cycles_late) {
if (change_mic_impl_requested.exchange(false)) {
CreateMic();
}
// If the event was scheduled before the application requested the mic to stop sampling
if (!mic->IsSampling()) {
return;
}
Frontend::Mic::Samples samples = mic->Read();
if (!samples.empty()) {
// write the samples to sharedmem page
state.WriteSamples(samples);
}
// schedule next run
timing.ScheduleEvent(GetBufferUpdateRate(state.sample_rate) - cycles_late,
buffer_write_event);
}
void StartSampling(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x03, 5, 0};
encoding = rp.PopEnum<Encoding>();
sample_rate = rp.PopEnum<SampleRate>();
audio_buffer_offset = rp.PopRaw<s32>();
audio_buffer_size = rp.Pop<u32>();
audio_buffer_loop = rp.Pop<bool>();
Encoding encoding = rp.PopEnum<Encoding>();
SampleRate sample_rate = rp.PopEnum<SampleRate>();
u32 audio_buffer_offset = rp.PopRaw<u32>();
u32 audio_buffer_size = rp.Pop<u32>();
bool audio_buffer_loop = rp.Pop<bool>();
if (mic->IsSampling()) {
LOG_CRITICAL(Service_MIC,
"Application started sampling again before stopping sampling");
mic->StopSampling();
}
auto sign = encoding == Encoding::PCM8Signed || encoding == Encoding::PCM16Signed
? Frontend::Mic::Signedness::Signed
: Frontend::Mic::Signedness::Unsigned;
u8 sample_size = encoding == Encoding::PCM8Signed || encoding == Encoding::PCM8 ? 8 : 16;
state.offset = state.initial_offset = audio_buffer_offset;
state.sample_rate = sample_rate;
state.sample_size = sample_size;
state.looped_buffer = audio_buffer_loop;
state.size = audio_buffer_size;
mic->StartSampling({sign, sample_size, audio_buffer_loop, GetSampleRateInHz(sample_rate),
audio_buffer_offset, audio_buffer_size});
timing.ScheduleEvent(GetBufferUpdateRate(state.sample_rate), buffer_write_event);
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
is_sampling = true;
LOG_WARNING(Service_MIC,
"(STUBBED) called, encoding={}, sample_rate={}, "
LOG_TRACE(Service_MIC,
"called, encoding={}, sample_rate={}, "
"audio_buffer_offset={}, audio_buffer_size={}, audio_buffer_loop={}",
static_cast<u32>(encoding), static_cast<u32>(sample_rate), audio_buffer_offset,
audio_buffer_size, audio_buffer_loop);
@ -78,31 +193,37 @@ struct MIC_U::Impl {
void AdjustSampling(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x04, 1, 0};
sample_rate = rp.PopEnum<SampleRate>();
SampleRate sample_rate = rp.PopEnum<SampleRate>();
mic->AdjustSampleRate(GetSampleRateInHz(sample_rate));
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_MIC, "(STUBBED) called, sample_rate={}", static_cast<u32>(sample_rate));
LOG_TRACE(Service_MIC, "sample_rate={}", static_cast<u32>(sample_rate));
}
void StopSampling(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x05, 0, 0};
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
is_sampling = false;
LOG_WARNING(Service_MIC, "(STUBBED) called");
mic->StopSampling();
timing.RemoveEvent(buffer_write_event);
LOG_TRACE(Service_MIC, "called");
}
void IsSampling(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x06, 0, 0};
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS);
bool is_sampling = mic->IsSampling();
rb.Push<bool>(is_sampling);
LOG_WARNING(Service_MIC, "(STUBBED) called");
LOG_TRACE(Service_MIC, "IsSampling: {}", is_sampling);
}
void GetBufferFullEvent(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x07, 0, 0};
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
rb.Push(RESULT_SUCCESS);
rb.PushCopyObjects(buffer_full_event);
@ -111,11 +232,12 @@ struct MIC_U::Impl {
void SetGain(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x08, 1, 0};
mic_gain = rp.Pop<u8>();
u8 gain = rp.Pop<u8>();
mic->SetGain(gain);
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_MIC, "(STUBBED) called, mic_gain={}", mic_gain);
LOG_TRACE(Service_MIC, "gain={}", gain);
}
void GetGain(Kernel::HLERequestContext& ctx) {
@ -123,25 +245,29 @@ struct MIC_U::Impl {
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS);
rb.Push<u8>(mic_gain);
LOG_WARNING(Service_MIC, "(STUBBED) called");
u8 gain = mic->GetGain();
rb.Push<u8>(gain);
LOG_TRACE(Service_MIC, "gain={}", gain);
}
void SetPower(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x0A, 1, 0};
mic_power = rp.Pop<bool>();
bool power = rp.Pop<bool>();
mic->SetPower(power);
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_MIC, "(STUBBED) called, mic_power={}", mic_power);
LOG_TRACE(Service_MIC, "mic_power={}", power);
}
void GetPower(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x0B, 0, 0};
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS);
bool mic_power = mic->GetPower();
rb.Push<u8>(mic_power);
LOG_WARNING(Service_MIC, "(STUBBED) called");
LOG_TRACE(Service_MIC, "called");
}
void SetIirFilterMic(Kernel::HLERequestContext& ctx) {
@ -167,6 +293,7 @@ struct MIC_U::Impl {
void GetClamp(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x0E, 0, 0};
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
rb.Push(RESULT_SUCCESS);
rb.Push<bool>(clamp);
@ -184,7 +311,6 @@ struct MIC_U::Impl {
void SetClientVersion(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx, 0x10, 1, 0};
const u32 version = rp.Pop<u32>();
LOG_WARNING(Service_MIC, "(STUBBED) called, version: 0x{:08X}", version);
@ -192,19 +318,51 @@ struct MIC_U::Impl {
rb.Push(RESULT_SUCCESS);
}
u32 client_version = 0;
void CreateMic() {
std::unique_ptr<Frontend::Mic::Interface> new_mic;
switch (Settings::values.mic_input_type) {
case Settings::MicInputType::None:
new_mic = std::make_unique<Frontend::Mic::NullMic>();
break;
case Settings::MicInputType::Real:
#if HAVE_CUBEB
new_mic = std::make_unique<AudioCore::CubebInput>();
#else
new_mic = std::make_unique<Frontend::Mic::NullMic>();
#endif
break;
case Settings::MicInputType::Static:
new_mic = std::make_unique<Frontend::Mic::StaticMic>();
break;
default:
LOG_CRITICAL(Audio, "Mic type not found. Defaulting to null mic");
new_mic = std::make_unique<Frontend::Mic::NullMic>();
}
// If theres already a mic, copy over any data to the new mic impl
if (mic) {
new_mic->SetGain(mic->GetGain());
new_mic->SetPower(mic->GetPower());
auto params = mic->GetParameters();
if (mic->IsSampling()) {
mic->StopSampling();
new_mic->StartSampling(params);
}
}
mic = std::move(new_mic);
change_mic_impl_requested.store(false);
}
std::atomic<bool> change_mic_impl_requested = false;
Kernel::SharedPtr<Kernel::Event> buffer_full_event;
Core::TimingEventType* buffer_write_event = nullptr;
Kernel::SharedPtr<Kernel::SharedMemory> shared_memory;
u8 mic_gain = 0;
bool mic_power = false;
bool is_sampling = false;
bool allow_shell_closed;
u32 client_version = 0;
bool allow_shell_closed = false;
bool clamp = false;
Encoding encoding = Encoding::PCM8;
SampleRate sample_rate = SampleRate::SampleRate32730;
s32 audio_buffer_offset = 0;
u32 audio_buffer_size = 0;
bool audio_buffer_loop = false;
std::unique_ptr<Frontend::Mic::Interface> mic;
Core::Timing& timing;
State state{};
};
void MIC_U::MapSharedMem(Kernel::HLERequestContext& ctx) {
@ -292,10 +450,24 @@ MIC_U::MIC_U(Core::System& system)
{0x00100040, &MIC_U::SetClientVersion, "SetClientVersion"},
};
impl->CreateMic();
RegisterHandlers(functions);
}
MIC_U::~MIC_U() = default;
MIC_U::~MIC_U() {
impl->mic->StopSampling();
}
void MIC_U::ReloadMic() {
impl->change_mic_impl_requested.store(true);
}
void ReloadMic(Core::System& system) {
auto micu = system.ServiceManager().GetService<Service::MIC::MIC_U>("mic:u");
if (!micu)
return;
micu->ReloadMic();
}
void InstallInterfaces(Core::System& system) {
auto& service_manager = system.ServiceManager();

4
src/core/hle/service/mic_u.h
View File

@ -19,6 +19,8 @@ public:
explicit MIC_U(Core::System& system);
~MIC_U();
void ReloadMic();
private:
/**
* MIC::MapSharedMem service function
@ -190,6 +192,8 @@ private:
std::unique_ptr<Impl> impl;
};
void ReloadMic(Core::System& system);
void InstallInterfaces(Core::System& system);
} // namespace Service::MIC

5
src/core/settings.cpp
View File

@ -9,6 +9,7 @@
#include "core/hle/service/hid/hid.h"
#include "core/hle/service/ir/ir_rst.h"
#include "core/hle/service/ir/ir_user.h"
#include "core/hle/service/mic_u.h"
#include "core/settings.h"
#include "video_core/renderer_base.h"
#include "video_core/video_core.h"
@ -56,6 +57,8 @@ void Apply() {
if (cam) {
cam->ReloadCameraDevices();
}
Service::MIC::ReloadMic(system);
}
}
@ -86,6 +89,8 @@ void LogSettings() {
LogSetting("Audio_OutputEngine", Settings::values.sink_id);
LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);
LogSetting("Audio_InputDeviceType", static_cast<int>(Settings::values.mic_input_type));
LogSetting("Audio_InputDevice", Settings::values.mic_input_device);
using namespace Service::CAM;
LogSetting("Camera_OuterRightName", Settings::values.camera_name[OuterRightCamera]);
LogSetting("Camera_OuterRightConfig", Settings::values.camera_config[OuterRightCamera]);

8
src/core/settings.h
View File

@ -26,6 +26,12 @@ enum class LayoutOption {
SideScreen,
};
enum class MicInputType {
None,
Real,
Static,
};
namespace NativeButton {
enum Values {
A,
@ -167,6 +173,8 @@ struct Values {
bool enable_audio_stretching;
std::string audio_device_id;
float volume;
MicInputType mic_input_type;
std::string mic_input_device;
// Camera
std::array<std::string, Service::CAM::NumCameras> camera_name;