citra/src/audio_core/sdl2_sink.cpp

148 lines
4.7 KiB
C++
Raw Normal View History

2016-04-27 10:57:29 +01:00
// Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <list>
#include <numeric>
2016-04-27 10:57:29 +01:00
#include <SDL.h>
2017-12-20 18:44:32 +00:00
#include "audio_core/audio_types.h"
#include "audio_core/sdl2_sink.h"
2016-04-27 10:57:29 +01:00
#include "common/assert.h"
#include "common/logging/log.h"
namespace AudioCore {
struct SDL2Sink::Impl {
unsigned int sample_rate = 0;
SDL_AudioDeviceID audio_device_id = 0;
std::list<std::vector<s16>> queue;
static void Callback(void* impl_, u8* buffer, int buffer_size_in_bytes);
};
SDL2Sink::SDL2Sink(std::string device_name) : impl(std::make_unique<Impl>()) {
2016-04-27 10:57:29 +01:00
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
2018-06-29 12:18:07 +01:00
LOG_CRITICAL(Audio_Sink, "SDL_Init(SDL_INIT_AUDIO) failed with: {}", SDL_GetError());
2016-04-27 10:57:29 +01:00
impl->audio_device_id = 0;
return;
}
SDL_AudioSpec desired_audiospec;
SDL_zero(desired_audiospec);
desired_audiospec.format = AUDIO_S16;
desired_audiospec.channels = 2;
desired_audiospec.freq = native_sample_rate;
2016-09-07 15:26:38 +01:00
desired_audiospec.samples = 512;
2016-04-27 10:57:29 +01:00
desired_audiospec.userdata = impl.get();
desired_audiospec.callback = &Impl::Callback;
SDL_AudioSpec obtained_audiospec;
SDL_zero(obtained_audiospec);
const char* device = nullptr;
2018-07-12 15:52:06 +01:00
if (device_name != auto_device_name && !device_name.empty()) {
device = device_name.c_str();
}
impl->audio_device_id = SDL_OpenAudioDevice(
device, false, &desired_audiospec, &obtained_audiospec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE);
2016-04-27 10:57:29 +01:00
if (impl->audio_device_id <= 0) {
2018-06-29 12:18:07 +01:00
LOG_CRITICAL(Audio_Sink, "SDL_OpenAudioDevice failed with code {} for device \"{}\"",
impl->audio_device_id, device_name);
2016-04-27 10:57:29 +01:00
return;
}
impl->sample_rate = obtained_audiospec.freq;
// SDL2 audio devices start out paused, unpause it:
SDL_PauseAudioDevice(impl->audio_device_id, 0);
}
SDL2Sink::~SDL2Sink() {
if (impl->audio_device_id <= 0)
return;
SDL_CloseAudioDevice(impl->audio_device_id);
}
unsigned int SDL2Sink::GetNativeSampleRate() const {
if (impl->audio_device_id <= 0)
return native_sample_rate;
return impl->sample_rate;
}
void SDL2Sink::EnqueueSamples(const s16* samples, size_t sample_count) {
2016-04-27 10:57:29 +01:00
if (impl->audio_device_id <= 0)
return;
SDL_LockAudioDevice(impl->audio_device_id);
impl->queue.emplace_back(samples, samples + sample_count * 2);
2016-04-27 10:57:29 +01:00
SDL_UnlockAudioDevice(impl->audio_device_id);
}
size_t SDL2Sink::SamplesInQueue() const {
if (impl->audio_device_id <= 0)
return 0;
SDL_LockAudioDevice(impl->audio_device_id);
size_t total_size = std::accumulate(impl->queue.begin(), impl->queue.end(),
static_cast<size_t>(0), [](size_t sum, const auto& buffer) {
// Division by two because each stereo sample is made of
// two s16.
return sum + buffer.size() / 2;
});
2016-04-27 10:57:29 +01:00
SDL_UnlockAudioDevice(impl->audio_device_id);
return total_size;
}
void SDL2Sink::Impl::Callback(void* impl_, u8* buffer, int buffer_size_in_bytes) {
Impl* impl = reinterpret_cast<Impl*>(impl_);
size_t remaining_size = static_cast<size_t>(buffer_size_in_bytes) /
sizeof(s16); // Keep track of size in 16-bit increments.
2016-04-27 10:57:29 +01:00
while (remaining_size > 0 && !impl->queue.empty()) {
if (impl->queue.front().size() <= remaining_size) {
memcpy(buffer, impl->queue.front().data(), impl->queue.front().size() * sizeof(s16));
buffer += impl->queue.front().size() * sizeof(s16);
remaining_size -= impl->queue.front().size();
impl->queue.pop_front();
} else {
memcpy(buffer, impl->queue.front().data(), remaining_size * sizeof(s16));
buffer += remaining_size * sizeof(s16);
impl->queue.front().erase(impl->queue.front().begin(),
impl->queue.front().begin() + remaining_size);
2016-04-27 10:57:29 +01:00
remaining_size = 0;
}
}
if (remaining_size > 0) {
memset(buffer, 0, remaining_size * sizeof(s16));
}
}
std::vector<std::string> ListSDL2SinkDevices() {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem failed with: {}", SDL_GetError());
return {};
}
std::vector<std::string> device_list;
const int device_count = SDL_GetNumAudioDevices(0);
for (int i = 0; i < device_count; ++i) {
device_list.push_back(SDL_GetAudioDeviceName(i, 0));
}
SDL_QuitSubSystem(SDL_INIT_AUDIO);
return device_list;
}
2016-04-27 10:57:29 +01:00
} // namespace AudioCore