533 lines
17 KiB
C++
533 lines
17 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2013 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "xenia/apu/audio_system.h"
|
|
|
|
#include "xenia/apu/audio_driver.h"
|
|
#include "xenia/apu/audio_decoder.h"
|
|
#include "xenia/base/logging.h"
|
|
#include "xenia/base/math.h"
|
|
#include "xenia/cpu/processor.h"
|
|
#include "xenia/cpu/thread_state.h"
|
|
#include "xenia/emulator.h"
|
|
#include "xenia/kernel/objects/xthread.h"
|
|
#include "xenia/profiling.h"
|
|
|
|
// As with normal Microsoft, there are like twelve different ways to access
|
|
// the audio APIs. Early games use XMA*() methods almost exclusively to touch
|
|
// decoders. Later games use XAudio*() and direct memory writes to the XMA
|
|
// structures (as opposed to the XMA* calls), meaning that we have to support
|
|
// both.
|
|
//
|
|
// For ease of implementation, most audio related processing is handled in
|
|
// AudioSystem, and the functions here call off to it.
|
|
// The XMA*() functions just manipulate the audio system in the guest context
|
|
// and let the normal AudioSystem handling take it, to prevent duplicate
|
|
// implementations. They can be found in xboxkrnl_audio_xma.cc
|
|
//
|
|
// XMA details:
|
|
// https://devel.nuclex.org/external/svn/directx/trunk/include/xma2defs.h
|
|
// https://github.com/gdawg/fsbext/blob/master/src/xma_header.h
|
|
//
|
|
// XAudio2 uses XMA under the covers, and seems to map with the same
|
|
// restrictions of frame/subframe/etc:
|
|
// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.xaudio2.xaudio2_buffer(v=vs.85).aspx
|
|
//
|
|
// XMA contexts are 64b in size and tight bitfields. They are in physical
|
|
// memory not usually available to games. Games will use MmMapIoSpace to get
|
|
// the 64b pointer in user memory so they can party on it. If the game doesn't
|
|
// do this, it's likely they are either passing the context to XAudio or
|
|
// using the XMA* functions.
|
|
|
|
namespace xe {
|
|
namespace apu {
|
|
|
|
using namespace xe::cpu;
|
|
|
|
// Size of a hardware XMA context.
|
|
const uint32_t kXmaContextSize = 64;
|
|
// Total number of XMA contexts available.
|
|
const uint32_t kXmaContextCount = 320;
|
|
|
|
AudioSystem::AudioSystem(Emulator* emulator)
|
|
: emulator_(emulator), memory_(emulator->memory()), worker_running_(false),
|
|
decoder_running_(false) {
|
|
memset(clients_, 0, sizeof(clients_));
|
|
for (size_t i = 0; i < maximum_client_count_; ++i) {
|
|
unused_clients_.push(i);
|
|
}
|
|
for (size_t i = 0; i < xe::countof(client_wait_handles_); ++i) {
|
|
client_wait_handles_[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
}
|
|
}
|
|
|
|
AudioSystem::~AudioSystem() {
|
|
for (size_t i = 0; i < xe::countof(client_wait_handles_); ++i) {
|
|
CloseHandle(client_wait_handles_[i]);
|
|
}
|
|
}
|
|
|
|
X_STATUS AudioSystem::Setup() {
|
|
processor_ = emulator_->processor();
|
|
|
|
// Let the processor know we want register access callbacks.
|
|
emulator_->memory()->AddVirtualMappedRange(
|
|
0x7FEA0000, 0xFFFF0000, 0x0000FFFF, this,
|
|
reinterpret_cast<MMIOReadCallback>(MMIOReadRegisterThunk),
|
|
reinterpret_cast<MMIOWriteCallback>(MMIOWriteRegisterThunk));
|
|
|
|
// Setup XMA contexts ptr.
|
|
registers_.xma_context_array_ptr = memory()->SystemHeapAlloc(
|
|
kXmaContextSize * kXmaContextCount, 256, kSystemHeapPhysical);
|
|
// Add all contexts to the free list.
|
|
for (int i = kXmaContextCount - 1; i >= 0; --i) {
|
|
uint32_t ptr = registers_.xma_context_array_ptr + i * kXmaContextSize;
|
|
|
|
// Initialize it
|
|
xma_context_array_[i].guest_ptr = ptr;
|
|
xma_context_array_[i].in_use = false;
|
|
|
|
// Create a new decoder per context
|
|
// Needed because some data needs to be persisted across calls
|
|
// TODO: Need to destroy this on class destruction
|
|
xma_context_array_[i].decoder = new AudioDecoder();
|
|
xma_context_array_[i].decoder->Initialize(16);
|
|
}
|
|
registers_.next_context = 1;
|
|
|
|
// Threads
|
|
|
|
worker_running_ = true;
|
|
worker_thread_ = new kernel::XHostThread(emulator()->kernel_state(),
|
|
128 * 1024, 0, [this]() {
|
|
this->WorkerThreadMain();
|
|
return 0;
|
|
});
|
|
worker_thread_->Create();
|
|
|
|
decoder_running_ = true;
|
|
decoder_thread_ = std::thread(std::bind(&AudioSystem::DecoderThreadMain, this));
|
|
|
|
return X_STATUS_SUCCESS;
|
|
}
|
|
|
|
void AudioSystem::WorkerThreadMain() {
|
|
xe::threading::set_name("Audio Worker");
|
|
|
|
// Initialize driver and ringbuffer.
|
|
Initialize();
|
|
|
|
auto processor = emulator_->processor();
|
|
|
|
// Main run loop.
|
|
while (worker_running_) {
|
|
auto result =
|
|
WaitForMultipleObjectsEx(DWORD(xe::countof(client_wait_handles_)),
|
|
client_wait_handles_, FALSE, INFINITE, FALSE);
|
|
if (result == WAIT_FAILED ||
|
|
result == WAIT_OBJECT_0 + maximum_client_count_) {
|
|
continue;
|
|
}
|
|
|
|
size_t pumped = 0;
|
|
if (result >= WAIT_OBJECT_0 &&
|
|
result <= WAIT_OBJECT_0 + (maximum_client_count_ - 1)) {
|
|
size_t index = result - WAIT_OBJECT_0;
|
|
do {
|
|
lock_.lock();
|
|
uint32_t client_callback = clients_[index].callback;
|
|
uint32_t client_callback_arg = clients_[index].wrapped_callback_arg;
|
|
lock_.unlock();
|
|
|
|
if (client_callback) {
|
|
uint64_t args[] = {client_callback_arg};
|
|
processor->Execute(worker_thread_->thread_state(), client_callback,
|
|
args, xe::countof(args));
|
|
}
|
|
pumped++;
|
|
index++;
|
|
} while (index < maximum_client_count_ &&
|
|
WaitForSingleObject(client_wait_handles_[index], 0) ==
|
|
WAIT_OBJECT_0);
|
|
}
|
|
|
|
if (!worker_running_) {
|
|
break;
|
|
}
|
|
|
|
if (!pumped) {
|
|
SCOPE_profile_cpu_i("apu", "Sleep");
|
|
Sleep(500);
|
|
}
|
|
}
|
|
worker_running_ = false;
|
|
|
|
// TODO(benvanik): call module API to kill?
|
|
}
|
|
|
|
void AudioSystem::DecoderThreadMain() {
|
|
xe::threading::set_name("Audio Decoder");
|
|
xe::Profiler::ThreadEnter("Audio Decoder");
|
|
|
|
while (decoder_running_) {
|
|
// Wait for the fence
|
|
// FIXME: This actually does nothing once signaled once
|
|
decoder_fence_.Wait();
|
|
|
|
// Check to see if we're supposed to exit
|
|
if (!decoder_running_) {
|
|
break;
|
|
}
|
|
|
|
// Okay, let's loop through XMA contexts to find ones we need to decode!
|
|
for (uint32_t n = 0; n < kXmaContextCount; n++) {
|
|
XMAContext& context = xma_context_array_[n];
|
|
if (!context.lock.try_lock()) {
|
|
// Someone else has the lock.
|
|
continue;
|
|
}
|
|
|
|
// Skip unused contexts
|
|
if (!context.in_use) {
|
|
context.lock.unlock();
|
|
continue;
|
|
}
|
|
|
|
uint8_t* ptr = memory()->TranslatePhysical(context.guest_ptr);
|
|
auto data = XMAContextData(ptr);
|
|
|
|
if (data.input_buffer_0_valid || data.input_buffer_1_valid) {
|
|
// A buffer is valid. Run the decoder!
|
|
|
|
// Reset valid flags
|
|
data.input_buffer_0_valid = 0;
|
|
data.input_buffer_1_valid = 0;
|
|
data.output_buffer_valid = 0;
|
|
|
|
// Translate pointers for future use.
|
|
auto in0 = memory()->TranslatePhysical(data.input_buffer_0_ptr);
|
|
auto in1 = memory()->TranslatePhysical(data.input_buffer_1_ptr);
|
|
auto out = memory()->TranslatePhysical(data.output_buffer_ptr);
|
|
|
|
// I haven't seen this be used yet.
|
|
assert(!data.input_buffer_1_block_count);
|
|
|
|
// What I see:
|
|
// XMA outputs 2 bytes per sample
|
|
// 512 samples per frame (128 per subframe)
|
|
// Max output size is data.output_buffer_block_count * 256
|
|
|
|
// This decoder is fed packets (max 4095 per buffer)
|
|
// Packets contain "some" frames
|
|
// 32bit header (big endian)
|
|
|
|
// Frames are the smallest thing the SPUs can decode.
|
|
// They usually can span packets (libav handles this)
|
|
|
|
// Sample rates (data.sample_rate):
|
|
// 0 - 24 kHz ?
|
|
// 1 - 32 kHz
|
|
// 2 - 44.1 kHz ?
|
|
// 3 - 48 kHz ?
|
|
|
|
// SPUs also support stereo decoding. (data.is_stereo)
|
|
|
|
while (true) {
|
|
// Initial check - see if we've finished with the input
|
|
// TODO - Probably need to move this, I think it might skip the very
|
|
// last packet (see the call to PreparePacket)
|
|
size_t input_size = (data.input_buffer_0_block_count +
|
|
data.input_buffer_1_block_count) * 2048;
|
|
size_t input_offset = (data.input_buffer_read_offset / 8 - 4);
|
|
size_t input_remaining = input_size - input_offset;
|
|
if (input_remaining == 0) {
|
|
// We're finished!
|
|
break;
|
|
}
|
|
|
|
// Now check the output buffer.
|
|
size_t output_size = data.output_buffer_block_count * 256;
|
|
size_t output_offset = data.output_buffer_write_offset * 256;
|
|
size_t output_remaining = output_size - output_offset;
|
|
if (output_remaining == 0) {
|
|
// Can't write any more data. Break.
|
|
// The game will kick us again with a new output buffer later.
|
|
break;
|
|
}
|
|
|
|
// This'll copy audio samples into the output buffer.
|
|
// The samples need to be 2 bytes long!
|
|
// Copies one frame at a time, so keep calling this until size == 0
|
|
int read = context.decoder->DecodePacket(out, output_offset,
|
|
output_remaining);
|
|
if (read < 0) {
|
|
XELOGAPU("APU failed to decode packet (returned %.8X)", -read);
|
|
context.decoder->DiscardPacket();
|
|
|
|
// TODO: Set error state
|
|
|
|
break;
|
|
}
|
|
|
|
if (read == 0) {
|
|
// Select sample rate.
|
|
int sample_rate = 0;
|
|
if (data.sample_rate == 0) {
|
|
// TODO: Test this
|
|
sample_rate = 24000;
|
|
} else if (data.sample_rate == 1) {
|
|
sample_rate = 32000;
|
|
} else if (data.sample_rate == 2) {
|
|
// TODO: Test this
|
|
sample_rate = 44100;
|
|
} else if (data.sample_rate == 3) {
|
|
// TODO: Test this
|
|
sample_rate = 48000;
|
|
}
|
|
|
|
// Channels
|
|
int channels = 1;
|
|
if (data.is_stereo == 1) {
|
|
channels = 2;
|
|
}
|
|
|
|
// New packet time.
|
|
// TODO: Select input buffer 1 if necessary.
|
|
auto packet = in0 + input_offset;
|
|
context.decoder->PreparePacket(packet, 2048, sample_rate, channels);
|
|
input_offset += 2048;
|
|
}
|
|
|
|
output_offset += read;
|
|
|
|
// blah copy these back to the context
|
|
data.input_buffer_read_offset = (input_offset + 4) * 8;
|
|
data.output_buffer_write_offset = output_offset / 256;
|
|
}
|
|
|
|
data.Store(ptr);
|
|
}
|
|
|
|
context.lock.unlock();
|
|
}
|
|
}
|
|
|
|
xe::Profiler::ThreadExit();
|
|
}
|
|
|
|
void AudioSystem::Initialize() {}
|
|
|
|
void AudioSystem::Shutdown() {
|
|
worker_running_ = false;
|
|
SetEvent(client_wait_handles_[maximum_client_count_]);
|
|
worker_thread_->Wait(0, 0, 0, nullptr);
|
|
worker_thread_->Release();
|
|
|
|
decoder_running_ = false;
|
|
decoder_fence_.Signal();
|
|
|
|
memory()->SystemHeapFree(registers_.xma_context_array_ptr);
|
|
}
|
|
|
|
uint32_t AudioSystem::AllocateXmaContext() {
|
|
std::lock_guard<std::mutex> lock(lock_);
|
|
|
|
for (uint32_t n = 0; n < kXmaContextCount; n++) {
|
|
XMAContext& context = xma_context_array_[n];
|
|
if (!context.in_use) {
|
|
context.in_use = true;
|
|
return context.guest_ptr;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void AudioSystem::ReleaseXmaContext(uint32_t guest_ptr) {
|
|
std::lock_guard<std::mutex> lock(lock_);
|
|
|
|
// Find it in the list.
|
|
for (uint32_t n = 0; n < kXmaContextCount; n++) {
|
|
XMAContext& context = xma_context_array_[n];
|
|
if (context.guest_ptr == guest_ptr) {
|
|
// Found it!
|
|
// Lock it in case the decoder thread is working on it now
|
|
context.lock.lock();
|
|
|
|
context.in_use = false;
|
|
auto context_ptr = memory()->TranslateVirtual(guest_ptr);
|
|
std::memset(context_ptr, 0, kXmaContextSize); // Zero it.
|
|
context.decoder->DiscardPacket();
|
|
|
|
context.lock.unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
X_STATUS AudioSystem::RegisterClient(uint32_t callback, uint32_t callback_arg,
|
|
size_t* out_index) {
|
|
assert_true(unused_clients_.size());
|
|
std::lock_guard<std::mutex> lock(lock_);
|
|
|
|
auto index = unused_clients_.front();
|
|
|
|
auto wait_handle = client_wait_handles_[index];
|
|
ResetEvent(wait_handle);
|
|
AudioDriver* driver;
|
|
auto result = CreateDriver(index, wait_handle, &driver);
|
|
if (XFAILED(result)) {
|
|
return result;
|
|
}
|
|
assert_not_null(driver);
|
|
|
|
unused_clients_.pop();
|
|
|
|
uint32_t ptr = memory()->SystemHeapAlloc(0x4);
|
|
xe::store_and_swap<uint32_t>(memory()->TranslateVirtual(ptr), callback_arg);
|
|
|
|
clients_[index] = {driver, callback, callback_arg, ptr};
|
|
|
|
if (out_index) {
|
|
*out_index = index;
|
|
}
|
|
|
|
return X_STATUS_SUCCESS;
|
|
}
|
|
|
|
void AudioSystem::SubmitFrame(size_t index, uint32_t samples_ptr) {
|
|
SCOPE_profile_cpu_f("apu");
|
|
|
|
std::lock_guard<std::mutex> lock(lock_);
|
|
assert_true(index < maximum_client_count_);
|
|
assert_true(clients_[index].driver != NULL);
|
|
(clients_[index].driver)->SubmitFrame(samples_ptr);
|
|
ResetEvent(client_wait_handles_[index]);
|
|
}
|
|
|
|
void AudioSystem::UnregisterClient(size_t index) {
|
|
SCOPE_profile_cpu_f("apu");
|
|
|
|
std::lock_guard<std::mutex> lock(lock_);
|
|
assert_true(index < maximum_client_count_);
|
|
DestroyDriver(clients_[index].driver);
|
|
clients_[index] = {0};
|
|
unused_clients_.push(index);
|
|
ResetEvent(client_wait_handles_[index]);
|
|
}
|
|
|
|
// free60 may be useful here, however it looks like it's using a different
|
|
// piece of hardware:
|
|
// https://github.com/Free60Project/libxenon/blob/master/libxenon/drivers/xenon_sound/sound.c
|
|
|
|
uint64_t AudioSystem::ReadRegister(uint32_t addr) {
|
|
uint32_t r = addr & 0xFFFF;
|
|
XELOGAPU("ReadRegister(%.4X)", r);
|
|
// 1800h is read on startup and stored -- context? buffers?
|
|
// 1818h is read during a lock?
|
|
|
|
assert_true(r % 4 == 0);
|
|
uint32_t value = register_file_[r / 4];
|
|
|
|
// 1818 is rotating context processing # set to hardware ID of context being
|
|
// processed.
|
|
// If bit 200h is set, the locking code will possibly collide on hardware IDs
|
|
// and error out, so we should never set it (I think?).
|
|
if (r == 0x1818) {
|
|
// To prevent games from seeing a stuck XMA context, return a rotating
|
|
// number
|
|
registers_.current_context = registers_.next_context;
|
|
registers_.next_context = (registers_.next_context + 1) % kXmaContextCount;
|
|
value = registers_.current_context;
|
|
}
|
|
|
|
value = xe::byte_swap(value);
|
|
return value;
|
|
}
|
|
|
|
void AudioSystem::WriteRegister(uint32_t addr, uint64_t value) {
|
|
uint32_t r = addr & 0xFFFF;
|
|
value = xe::byte_swap(uint32_t(value));
|
|
XELOGAPU("WriteRegister(%.4X, %.8X)", r, value);
|
|
// 1804h is written to with 0x02000000 and 0x03000000 around a lock operation
|
|
|
|
assert_true(r % 4 == 0);
|
|
register_file_[r / 4] = uint32_t(value);
|
|
|
|
if (r >= 0x1940 && r <= 0x1940 + 9 * 4) {
|
|
// Context kick command.
|
|
// This will kick off the given hardware contexts.
|
|
// Basically, this kicks the SPU and says "hey, decode that audio!"
|
|
// XMAEnableContext
|
|
|
|
// The context ID is a bit in the range of the entire context array
|
|
for (int i = 0; value && i < 32; ++i) {
|
|
if (value & 1) {
|
|
uint32_t context_id = i + (r - 0x1940) / 4 * 32;
|
|
XMAContext& context = xma_context_array_[context_id];
|
|
|
|
context.lock.lock();
|
|
auto context_ptr = memory()->TranslateVirtual(context.guest_ptr);
|
|
XMAContextData data(context_ptr);
|
|
|
|
XELOGAPU("AudioSystem: kicking context %d (%d/%d bytes)", context_id,
|
|
data.input_buffer_read_offset, data.input_buffer_0_block_count
|
|
* XMAContextData::kBytesPerBlock);
|
|
|
|
// Reset valid flags so our audio decoder knows to process this one
|
|
data.input_buffer_0_valid = data.input_buffer_0_ptr != 0;
|
|
data.input_buffer_1_valid = data.input_buffer_1_ptr != 0;
|
|
data.output_buffer_write_offset = 0;
|
|
|
|
data.Store(context_ptr);
|
|
context.lock.unlock();
|
|
|
|
// Signal the decoder thread
|
|
decoder_fence_.Signal();
|
|
}
|
|
value >>= 1;
|
|
}
|
|
} else if (r >= 0x1A40 && r <= 0x1A40 + 9 * 4) {
|
|
// Context lock command.
|
|
// This requests a lock by flagging the context.
|
|
// XMADisableContext
|
|
for (int i = 0; value && i < 32; ++i) {
|
|
if (value & 1) {
|
|
uint32_t context_id = i + (r - 0x1A40) / 4 * 32;
|
|
XELOGAPU("AudioSystem: set context lock %d", context_id);
|
|
|
|
// TODO: Find the correct way to lock/unlock this.
|
|
// I thought we could lock it here, unlock it in the kick but that
|
|
// doesn't seem to work
|
|
XMAContext& context = xma_context_array_[context_id];
|
|
}
|
|
value >>= 1;
|
|
}
|
|
} else if (r >= 0x1A80 && r <= 0x1A80 + 9 * 4) {
|
|
// Context clear command.
|
|
// This will reset the given hardware contexts.
|
|
for (int i = 0; value && i < 32; ++i) {
|
|
if (value & 1) {
|
|
uint32_t context_id = i + (r - 0x1A80) / 4 * 32;
|
|
XELOGAPU("AudioSystem: reset context %d", context_id);
|
|
|
|
// TODO(benvanik): something?
|
|
uint32_t guest_ptr =
|
|
registers_.xma_context_array_ptr + context_id * kXmaContextSize;
|
|
auto context_ptr = memory()->TranslateVirtual(guest_ptr);
|
|
}
|
|
value >>= 1;
|
|
}
|
|
} else {
|
|
value = value;
|
|
}
|
|
}
|
|
|
|
} // namespace apu
|
|
} // namespace xe
|