Test Compile

src/xenia/app/xenia_main.cc

@@ -65,7 +65,7 @@
 DEFINE_string(apu, "any", "Audio system. Use: [any, nop, sdl, xaudio2]", "APU");
 DEFINE_string(gpu, "any", "Graphics system. Use: [any, d3d12, vulkan, null]",
               "GPU");
-DEFINE_string(hid, "any", "Input system. Use: [any, nop, sdl, winkey, xinput]",
+DEFINE_string(hid, "xinput", "Input system. Use: [any, nop, sdl, winkey, xinput]",
               "HID");
 
 DEFINE_path(

src/xenia/apu/audio_system.cc

@@ -21,8 +21,9 @@
 #include "xenia/base/string_buffer.h"
 #include "xenia/base/threading.h"
 #include "xenia/cpu/thread_state.h"
+#include "xenia/emulator.h"
 #include "xenia/kernel/kernel_state.h"
-
+#include "xenia/kernel/xboxkrnl/xboxkrnl_threading.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
@@ -35,13 +36,19 @@
 // and let the normal AudioSystem handling take it, to prevent duplicate
 // implementations. They can be found in xboxkrnl_audio_xma.cc
 
-DEFINE_uint32(
-    apu_max_queued_frames, 64,
-    "Allows changing max buffered audio frames to reduce audio delay. Minimum is 16.", "APU");
+DEFINE_uint32(apu_max_queued_frames, 64,
+              "Allows changing max buffered audio frames to reduce audio "
+              "delay. Minimum is 16.",
+              "APU");
 
+#define AUDIOSYSTEM_NOWAIT_FOR_CALLBACK 1
 namespace xe {
 namespace apu {
-
+struct GuestMessage {
+  threading::AtomicListEntry list_entry;
+  uint32_t client_callback_;
+  uint32_t client_callback_arg_;
+};
 AudioSystem::AudioSystem(cpu::Processor* processor)
     : memory_(processor->memory()),
       processor_(processor),
@@ -60,6 +67,7 @@ AudioSystem::AudioSystem(cpu::Processor* processor)
   xma_decoder_ = std::make_unique<xe::apu::XmaDecoder>(processor_);
 
   resume_event_ = xe::threading::Event::CreateAutoResetEvent(false);
+  signal_event_ = xe::threading::Event::CreateAutoResetEvent(false);
   assert_not_null(resume_event_);
 }
 
@@ -74,21 +82,78 @@ X_STATUS AudioSystem::Setup(kernel::KernelState* kernel_state) {
   if (result) {
     return result;
   }
-
+  kernel_state_ = kernel_state;
   worker_running_ = true;
-  worker_thread_ = kernel::object_ref<kernel::XHostThread>(
-      new kernel::XHostThread(kernel_state, 128 * 1024, 0, [this]() {
-        WorkerThreadMain();
-        return 0;
-      }, kernel_state->GetSystemProcess()));
+
+  threading::Thread::CreationParameters crparams{};
+  worker_thread_ = threading::Thread::Create(
+      crparams, std::bind(&AudioSystem::WorkerThreadMain, this));
+  Emulator::Get()->RegisterGuestHardwareBlockThread(worker_thread_.get());
   // As we run audio callbacks the debugger must be able to suspend us.
-  worker_thread_->set_can_debugger_suspend(true);
   worker_thread_->set_name("Audio Worker");
-  worker_thread_->Create();
+  worker_thread_->set_affinity_mask(0b11000000);
 
   return X_STATUS_SUCCESS;
 }
-
+void AudioSystem::StartGuestWorkerThread(kernel::KernelState* kernel) {
+  xenia_assert(!guest_thread_);
+  auto context = cpu::ThreadState::GetContext();
+  guest_thread_ =
+      kernel::object_ref<kernel::XHostThread>(new kernel::XHostThread(
+          kernel, 65536U, 0x10000083u,
+          [this]() {
+            std::vector<GuestMessage*> messages_rev{};
+            messages_rev.reserve(128);
+            auto context = cpu::ThreadState::GetContext();
+            while (true) {
+              kernel::xboxkrnl::xeKeWaitForSingleObject(
+                  context,
+                  &context->kernel_state->GetKernelGuestGlobals(context)
+                       ->audio_interrupt_dpc_event_.header,
+                  0, 0, 0, nullptr);
+
+              auto callbacks = guest_worker_messages_.Flush();
+
+              if (!callbacks) {
+                //xenia_assert(false);
+                continue;
+              }
+              kernel::xboxkrnl::xeKeEnterCriticalRegion(context);
+              while (callbacks) {
+                messages_rev.push_back((GuestMessage*)callbacks);
+                callbacks = callbacks->next_;
+                context->CheckInterrupt();
+              }
+              std::reverse(messages_rev.begin(), messages_rev.end());
+
+              for (auto&& order : messages_rev) {
+                uint64_t args[] = {order->client_callback_arg_};
+                auto kpcr = kernel::GetKPCR(context);
+
+                auto current_irql = kpcr->current_irql;
+
+                xenia_assert(current_irql == kernel::IRQL_PASSIVE);
+                this->processor()->Execute(context->thread_state(),
+                                           order->client_callback_, args,
+                                           countof(args));
+                delete order;
+                context->CheckInterrupt();
+#if AUDIOSYSTEM_NOWAIT_FOR_CALLBACK == 0
+                signal_event_->Set();
+#endif
+              }
+              messages_rev.clear();
+              kernel::xboxkrnl::xeKeLeaveCriticalRegion(context);
+            }
+            return true;
+          },
+          kernel->GetSystemProcess()));
+  guest_thread_->Create();
+  kernel::xboxkrnl::xeKeSetPriorityThread(
+      context, guest_thread_->guest_object<kernel::X_KTHREAD>(), 25);
+  kernel::xboxkrnl::xeKeResumeThread(
+      context, guest_thread_->guest_object<kernel::X_KTHREAD>());
+}
 void AudioSystem::WorkerThreadMain() {
   // Initialize driver and ringbuffer.
   Initialize();
@@ -120,19 +185,28 @@ void AudioSystem::WorkerThreadMain() {
     bool pumped = false;
     if (result.first == xe::threading::WaitResult::kSuccess) {
       auto index = result.second;
-
       auto global_lock = global_critical_region_.Acquire();
       uint32_t client_callback = clients_[index].callback;
       uint32_t client_callback_arg = clients_[index].wrapped_callback_arg;
       global_lock.unlock();
-
-      if (client_callback) {
-        SCOPE_profile_cpu_i("apu", "xe::apu::AudioSystem->client_callback");
-        uint64_t args[] = {client_callback_arg};
-        processor_->Execute(worker_thread_->thread_state(), client_callback,
-                            args, xe::countof(args));
+      client_callback_arg_in_ = client_callback_arg;
+      client_callback_in_ = client_callback;
+
+      auto msg = new GuestMessage();
+      msg->client_callback_ = client_callback_in_;
+      msg->client_callback_arg_ = client_callback_arg_in_;
+      guest_worker_messages_.Push(&msg->list_entry);
+      {
+        cpu::SendInterruptArguments interrupt_arguments{};
+        interrupt_arguments.ipi_func = &kernel::KernelState::AudioInterrupt;
+        interrupt_arguments.ud = nullptr;
+        interrupt_arguments.wait_done = false;
+        interrupt_arguments.irql_ = kernel::IRQL_AUDIO;
+        processor()->GetCPUThread(4)->SendGuestIPI(interrupt_arguments);
       }
-
+#if AUDIOSYSTEM_NOWAIT_FOR_CALLBACK == 0
+      threading::Wait(signal_event_.get(), false);
+#endif
       pumped = true;
     }
 
@@ -167,7 +241,8 @@ void AudioSystem::Shutdown() {
   worker_running_ = false;
   shutdown_event_->Set();
   if (worker_thread_) {
-    worker_thread_->Wait(0, 0, 0, nullptr);
+    threading::Wait(worker_thread_.get(), false);
+    Emulator::Get()->UnregisterGuestHardwareBlockThread(worker_thread_.get());
     worker_thread_.reset();
   }
 }
@@ -290,7 +365,9 @@ bool AudioSystem::Restore(ByteStream* stream) {
     auto status = CreateDriver(id, client_semaphore, &driver);
     if (XFAILED(status)) {
       XELOGE(
-          "AudioSystem::Restore - Call to CreateDriver failed with status "
+          "AudioSystem::Restore - "
+          "Call to CreateDriver "
+          "failed with status "
           "{:08X}",
           status);
       return false;

src/xenia/apu/audio_system.h

@@ -51,13 +51,17 @@ class AudioSystem {
   void Pause();
   void Resume();
 
+  //called by kernelstate in boot. actually called prior to Setup
+  void StartGuestWorkerThread(kernel::KernelState* kernel);
  protected:
   explicit AudioSystem(cpu::Processor* processor);
 
   virtual void Initialize();
 
   void WorkerThreadMain();
 
+
+
   virtual X_STATUS CreateDriver(size_t index,
                                 xe::threading::Semaphore* semaphore,
                                 AudioDriver** out_driver) = 0;
@@ -69,12 +73,13 @@ class AudioSystem {
 
   Memory* memory_ = nullptr;
   cpu::Processor* processor_ = nullptr;
+  kernel::KernelState* kernel_state_ = nullptr;
   std::unique_ptr<XmaDecoder> xma_decoder_;
   uint32_t queued_frames_;
 
   std::atomic<bool> worker_running_ = {false};
-  kernel::object_ref<kernel::XHostThread> worker_thread_;
-
+  std::unique_ptr<threading::Thread> worker_thread_;
+  kernel::object_ref<kernel::XHostThread> guest_thread_; 
   xe::global_critical_region global_critical_region_;
   static const size_t kMaximumClientCount = 8;
   struct {
@@ -96,6 +101,11 @@ class AudioSystem {
   bool paused_ = false;
   threading::Fence pause_fence_;
   std::unique_ptr<threading::Event> resume_event_;
+  std::unique_ptr<threading::Event> signal_event_;
+  uint32_t client_callback_in_;
+  uint32_t client_callback_arg_in_;
+
+  threading::AtomicListHeader guest_worker_messages_;
 };
 
 }  // namespace apu

src/xenia/apu/xma_context.cc

@@ -92,6 +92,20 @@ int XmaContext::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) {
   return 0;
 }
 
+bool XmaContext::is_allocated() {
+  return XmaDecoder::BoolsForContext(this)->is_allocated_;
+}
+bool XmaContext::is_enabled() {
+  return XmaDecoder::BoolsForContext(this)->is_enabled_;
+}
+
+void XmaContext::set_is_allocated(bool is_allocated) {
+  XmaDecoder::BoolsForContext(this)->is_allocated_ = is_allocated;
+}
+void XmaContext::set_is_enabled(bool is_enabled) {
+  XmaDecoder::BoolsForContext(this)->is_enabled_ = is_enabled;
+}
+
 bool XmaContext::Work() {
   if (!is_enabled() || !is_allocated()) {
     return false;
@@ -168,7 +182,7 @@ void XmaContext::Disable() {
 void XmaContext::Release() {
   // Lock it in case the decoder thread is working on it now.
   std::lock_guard<xe_mutex> lock(lock_);
-  assert_true(is_allocated_ == true);
+  assert_true(is_allocated() == true);
 
   set_is_allocated(false);
   auto context_ptr = memory()->TranslateVirtual(guest_ptr());

src/xenia/apu/xma_context.h

@@ -130,6 +130,11 @@ struct Xma2ExtraData {
 static_assert_size(Xma2ExtraData, 34);
 #pragma pack(pop)
 
+struct XmaContextBools {
+  volatile bool is_allocated_ = false;
+  volatile bool is_enabled_ = false;
+};
+
 class XmaContext {
  public:
   static const uint32_t kBytesPerPacket = 2048;
@@ -163,11 +168,11 @@ class XmaContext {
 
   uint32_t id() { return id_; }
   uint32_t guest_ptr() { return guest_ptr_; }
-  bool is_allocated() { return is_allocated_; }
-  bool is_enabled() { return is_enabled_; }
+  bool is_allocated();
+  bool is_enabled();
 
-  void set_is_allocated(bool is_allocated) { is_allocated_ = is_allocated; }
-  void set_is_enabled(bool is_enabled) { is_enabled_ = is_enabled; }
+  void set_is_allocated(bool is_allocated);
+  void set_is_enabled(bool is_enabled);
 
  private:
   static void SwapInputBuffer(XMA_CONTEXT_DATA* data);
@@ -205,8 +210,6 @@ class XmaContext {
   uint32_t id_ = 0;
   uint32_t guest_ptr_ = 0;
   xe_mutex lock_;
-  volatile bool is_allocated_ = false;
-  volatile bool is_enabled_ = false;
   // bool is_dirty_ = true;
 
   // ffmpeg structures

src/xenia/apu/xma_decoder.cc

@@ -18,8 +18,9 @@
 #include "xenia/base/string_buffer.h"
 #include "xenia/cpu/processor.h"
 #include "xenia/cpu/thread_state.h"
-#include "xenia/kernel/xthread.h"
+#include "xenia/emulator.h"
 #include "xenia/kernel/kernel_state.h"
+#include "xenia/kernel/xthread.h"
 extern "C" {
 #include "third_party/FFmpeg/libavutil/log.h"
 }  // extern "C"
@@ -102,8 +103,7 @@ void av_log_callback(void* avcl, int level, const char* fmt, va_list va) {
   StringBuffer buff;
   buff.AppendVarargs(fmt, va);
   xe::logging::AppendLogLineFormat(LogSrc::Apu, log_level, level_char,
-                                   "ffmpeg: {}",
-                                   buff.to_string_view());
+                                   "ffmpeg: {}", buff.to_string_view());
 }
 
 X_STATUS XmaDecoder::Setup(kernel::KernelState* kernel_state) {
@@ -141,24 +141,38 @@ X_STATUS XmaDecoder::Setup(kernel::KernelState* kernel_state) {
   worker_running_ = true;
   work_event_ = xe::threading::Event::CreateAutoResetEvent(false);
   assert_not_null(work_event_);
-  worker_thread_ = kernel::object_ref<kernel::XHostThread>(
-      new kernel::XHostThread(kernel_state, 128 * 1024, 0, [this]() {
-        WorkerThreadMain();
-        return 0;
-      }, kernel_state->GetIdleProcess()));//this one doesnt need any process actually. never calls any guest code
+  threading::Thread::CreationParameters crparams{};
+  crparams.stack_size = 16 * 1024 * 1024;
+  worker_thread_ = threading::Thread::Create(
+      crparams, std::bind(&XmaDecoder::WorkerThreadMain, this));
+  Emulator::Get()->RegisterGuestHardwareBlockThread(worker_thread_.get());
   worker_thread_->set_name("XMA Decoder");
-  worker_thread_->set_can_debugger_suspend(true);
-  worker_thread_->Create();
+  worker_thread_->set_affinity_mask(0b11000000);
 
   return X_STATUS_SUCCESS;
 }
+XmaContextBools* XmaDecoder::BoolsForContext(XmaContext* context) {
+  size_t delta_to_context_bools =
+      offsetof(XmaDecoder, contexts_) - offsetof(XmaDecoder, context_bools_);
+
+  size_t delta_to_context_base = context->id() * sizeof(XmaContext);
+
+  return reinterpret_cast<XmaContextBools*>(
+      ((reinterpret_cast<uintptr_t>(context) - delta_to_context_base) -
+       delta_to_context_bools) +
+      context->id() * sizeof(XmaContextBools));
+}
 
 void XmaDecoder::WorkerThreadMain() {
   uint32_t idle_loop_count = 0;
   while (worker_running_) {
     // Okay, let's loop through XMA contexts to find ones we need to decode!
     bool did_work = false;
     for (uint32_t n = 0; n < kContextCount; n++) {
+      if (!this->context_bools_[n].is_enabled_ ||
+          !this->context_bools_[n].is_allocated_) {
+        continue;
+      }
       XmaContext& context = contexts_[n];
       did_work = context.Work() || did_work;
 
@@ -195,7 +209,8 @@ void XmaDecoder::Shutdown() {
 
   if (worker_thread_) {
     // Wait for work thread.
-    xe::threading::Wait(worker_thread_->thread(), false);
+    xe::threading::Wait(worker_thread_.get(), false);
+    Emulator::Get()->UnregisterGuestHardwareBlockThread(worker_thread_.get());
     worker_thread_.reset();
   }