mirror of
https://github.com/Mr-Wiseguy/Zelda64Recomp.git
synced 2024-11-07 15:15:05 +01:00
91 lines
3.2 KiB
C++
91 lines
3.2 KiB
C++
#include "ultra64.h"
|
|
#include "multilibultra.hpp"
|
|
#include "SDL.h"
|
|
#include "SDL_audio.h"
|
|
#include <cassert>
|
|
|
|
static SDL_AudioDeviceID audio_device = 0;
|
|
static uint32_t sample_rate = 48000;
|
|
|
|
void Multilibultra::init_audio() {
|
|
// Initialize SDL audio.
|
|
SDL_InitSubSystem(SDL_INIT_AUDIO);
|
|
// Pick an initial dummy sample rate; this will be set by the game later to the true sample rate.
|
|
set_audio_frequency(48000);
|
|
}
|
|
|
|
void Multilibultra::set_audio_frequency(uint32_t freq) {
|
|
if (audio_device != 0) {
|
|
SDL_CloseAudioDevice(audio_device);
|
|
}
|
|
SDL_AudioSpec spec_desired{
|
|
.freq = (int)freq,
|
|
.format = AUDIO_S16,
|
|
.channels = 2,
|
|
.silence = 0, // calculated
|
|
.samples = 0x100, // Fairly small sample count to reduce the latency of internal buffering
|
|
.padding = 0, // unused
|
|
.size = 0, // calculated
|
|
.callback = nullptr,//feed_audio, // Use a callback as QueueAudio causes popping
|
|
.userdata = nullptr
|
|
};
|
|
|
|
audio_device = SDL_OpenAudioDevice(nullptr, false, &spec_desired, nullptr, 0);
|
|
if (audio_device == 0) {
|
|
printf("SDL Error: %s\n", SDL_GetError());
|
|
fflush(stdout);
|
|
assert(false);
|
|
}
|
|
SDL_PauseAudioDevice(audio_device, 0);
|
|
sample_rate = freq;
|
|
}
|
|
|
|
void Multilibultra::queue_audio_buffer(RDRAM_ARG PTR(s16) audio_data_, uint32_t byte_count) {
|
|
// Buffer for holding the output of swapping the audio channels. This is reused across
|
|
// calls to reduce runtime allocations.
|
|
static std::vector<uint16_t> swap_buffer;
|
|
|
|
// Ensure that the byte count is an integer multiple of samples.
|
|
assert((byte_count & 1) == 0);
|
|
|
|
// Calculate the number of samples from the number of bytes.
|
|
uint32_t sample_count = byte_count / sizeof(s16);
|
|
|
|
// Make sure the swap buffer is large enough to hold all the incoming audio data.
|
|
if (sample_count > swap_buffer.size()) {
|
|
swap_buffer.resize(sample_count);
|
|
}
|
|
|
|
// Swap the audio channels into the swap buffer to correct for the address xor caused by endianness handling.
|
|
s16* audio_data = TO_PTR(s16, audio_data_);
|
|
for (size_t i = 0; i < sample_count; i += 2) {
|
|
swap_buffer[i + 0] = audio_data[i + 1];
|
|
swap_buffer[i + 1] = audio_data[i + 0];
|
|
}
|
|
|
|
// Queue the swapped audio data.
|
|
SDL_QueueAudio(audio_device, swap_buffer.data(), byte_count);
|
|
}
|
|
|
|
uint32_t buffer_offset_frames = 1;
|
|
|
|
// If there's ever any audio popping, check here first. Some games are very sensitive to
|
|
// the remaining sample count and reporting a number that's too high here can lead to issues.
|
|
// Reporting a number that's too low can lead to audio lag in some games.
|
|
uint32_t Multilibultra::get_remaining_audio_bytes() {
|
|
// Get the number of remaining buffered audio bytes.
|
|
uint32_t buffered_byte_count = SDL_GetQueuedAudioSize(audio_device);
|
|
|
|
// Adjust the reported count to be some number of refreshes in the future, which helps ensure that
|
|
// there are enough samples even if the audio thread experiences a small amount of lag. This prevents
|
|
// audio popping on games that use the buffered audio byte count to determine how many samples
|
|
// to generate.
|
|
uint32_t samples_per_vi = (sample_rate / 60);
|
|
if (buffered_byte_count > (buffer_offset_frames * sizeof(int16_t) * samples_per_vi)) {
|
|
buffered_byte_count -= (buffer_offset_frames * sizeof(int16_t) * samples_per_vi);
|
|
} else {
|
|
buffered_byte_count = 0;
|
|
}
|
|
return buffered_byte_count;
|
|
}
|