Reborn audio

CMakeLists.txt

@@ -696,6 +696,7 @@ set(GAME_FILES
       extern/rstl/src/rstl/rstl_strings.cpp
       src/Metaforce/ARAMToken.cpp
       src/Metaforce/Alloc.cpp
+      src/Metaforce/Audio.cpp
       src/Metaforce/CModelSectionReader.cpp
       src/Metaforce/MapData.cpp
       src/Metaforce/PathData.cpp

include/Kyoto/Audio/CStaticAudioPlayer.hpp

@@ -9,7 +9,11 @@
 #include <rstl/vector.hpp>
 
 class CDvdRequest;
+#if defined(TARGET_PC)
+typedef void (*FAudioCallback)(short* output, size_t frames, u32 rate, u32 channels);
+#else
 typedef void (*FAudioCallback)();
+#endif
 
 class CStaticAudioPlayer {
 public:
@@ -20,12 +24,21 @@ class CStaticAudioPlayer {
   void StartMixOut();
   void StopMixOut();
 
+#if defined(TARGET_PC)
+  static void MixCallback(short* output, size_t frames, u32 rate, u32 channels);
+  void DoMix(short* output, size_t frames, u32 rate, u32 channels);
+#else
   static void MixCallback();
   void DoMix();
+#endif
   static void RunDMACallback(FAudioCallback);
   static void CancelDMACallback(FAudioCallback);
   static void InstallAICallback();
+#if defined(TARGET_PC)
+  static void AICallback(short* output, size_t frames, u32 rate, u32 channels);
+#else
   static void AICallback();
+#endif
 
   void Decode(const ushort* bufIn, ushort* bufOut, int numSamples);
   void DecodeMonoAndMix(ushort* bufIn, ushort* bufOut, int numSamples,
@@ -48,6 +61,13 @@ class CStaticAudioPlayer {
   g72x_state x58_leftState;
   g72x_state x8c_rightState;
   ushort xc0_volume;
+#if defined(TARGET_PC)
+  u32 m_audioPhase = 0;
+  short m_audioHistory[2][2] = {};
+  short m_audioPair[4] = {};
+  u32 m_audioPairRead = 2;
+  bool m_audioPrimed = false;
+#endif
 };
 
 #endif // _CSTATICAUDIOPLAYER

include/Kyoto/Graphics/CMoviePlayer.hpp

@@ -131,15 +131,23 @@ class CMoviePlayer {
 private:
   struct SIndexLoad;
   static void VerifyCallbackStatus();
+#if defined(TARGET_PC)
+  static void StaticMyAudioCallback(short* output, size_t frames, u32 rate, u32 channels);
+#else
   static void StaticMyAudioCallback();
+#endif
   void InitializeTextures();
   void ReadCompleted();
   void PostDVDReadRequestIfNeeded();
   CDvdFile x0_dvdFile;
   THPHeader x28_header;
   THPFrameCompInfo x58_thpComponents;
   THPVideoInfoOld x6c_videoInfo;
+#if defined(TARGET_PC)
+  THPAudioInfoOld x74_audioInfo{};
+#else
   THPAudioInfoOld x74_audioInfo;
+#endif
   rstl::vector< CTHPTextureSet > x80_textures;
   rstl::auto_ptr< uchar > x90_requestBuffer;
   rstl::single_ptr< CDvdRequest > x98_request;
@@ -168,6 +176,11 @@ class CMoviePlayer {
   bool xf4_27_fieldFlip : 1;
   uint xf8_cachedBytes;
   int xfc_fieldIndex;
+#if defined(TARGET_PC)
+  u32 m_audioPhase = 0;
+  short m_audioHistory[2][2] = {};
+  bool m_audioPrimed = false;
+#endif
 };
 CHECK_SIZEOF(CMoviePlayer, 0x100)
 

include/Metaforce/Audio.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <musyx/pc.h>
+#include <span>
+#include <string_view>
+
+struct dspadpcm_header;
+
+namespace metaforce {
+struct AudioGroupView {
+  std::string_view baseDirectory, name;
+  SND_PC_GROUP_ASSETS assets{};
+};
+struct AudioSongHeader {
+  u32 version, song, group, audioGroup, length;
+};
+
+void ConfigureAudio(SND_PC_CONFIG preferred, bool disabled);
+void InitializeAudio(u8 voices, u8 music, u8 sfx, u32 flags);
+void UpdateAudio();
+void LockAudio();
+void UnlockAudio();
+
+struct AudioLockGuard {
+  AudioLockGuard() { LockAudio(); }
+  ~AudioLockGuard() { UnlockAudio(); }
+  AudioLockGuard(const AudioLockGuard&) = delete;
+  AudioLockGuard& operator=(const AudioLockGuard&) = delete;
+};
+
+bool ReadAudioGroup(std::span< const u8 > bytes, AudioGroupView& result);
+bool ReadAudioSongHeader(std::span< const u8 > bytes, AudioSongHeader& result);
+bool ReadDSPHeader(std::span< const u8 > bytes, dspadpcm_header& result);
+} // namespace metaforce

src/Kyoto/Audio/CDSPStream.cpp

@@ -8,6 +8,9 @@
 #include "dolphin/os.h"
 
 #include <string.h>
+#if defined(TARGET_PC)
+#include "Metaforce/Audio.hpp"
+#endif
 
 static struct {
   CDSPStream streams[4];
@@ -109,10 +112,37 @@ void CDSPStream::Initialize() {
 }
 
 void CDSPStream::FreeAllStreams() {
+#if defined(TARGET_PC)
+  {
+    metaforce::AudioLockGuard lock;
+    for (auto& stream : g_Streams) {
+      stream.xe8_silenced = 1;
+      stream.xf0_stopRequested = 1;
+      if (stream.xc8_streamId != SND_ID_ERROR) sndStreamDeactivate(stream.xc8_streamId);
+    }
+  }
+  // DVD completion takes the same lock. Wait without holding it, and keep
+  // refill buffers alive until both requests and their callbacks have retired.
+  for (auto& stream : g_Streams) {
+    DVDCancel(&stream.x50_fileInfo1.cb);
+    DVDCancel(&stream.x8c_fileInfo2.cb);
+  }
+  metaforce::AudioLockGuard lock;
+  for (auto& stream : g_Streams) {
+    if (stream.x0_state != 0) stream.CloseFiles();
+    if (stream.xc8_streamId != SND_ID_ERROR) sndStreamFree(stream.xc8_streamId);
+    CMemory::Free(stream.xd4_buffer);
+    stream.xd4_buffer = nullptr;
+    stream.xc8_streamId = SND_ID_ERROR;
+    stream.x0_state = 0;
+    stream.x8_right = stream.xc_left = nullptr;
+  }
+#else
   for (uint i = 0; i < 4; ++i) {
     sndStreamFree(g_Streams[i].xc8_streamId);
     CMemory::Free(g_Streams[i].xd4_buffer);
   }
+#endif
 }
 
 uint CDSPStream::AllocateStream(const SStreamInfo& info, char vol, char pan) {
@@ -410,6 +440,9 @@ int CDSPStream::InitializeStream() {
 }
 
 void CDSPStream::ReadCompleted(s32, DVDFileInfo* fileInfo) {
+#if defined(TARGET_PC)
+  metaforce::AudioLockGuard lock;
+#endif
   int idx = 0;
   CDSPStream* s = g_Streams;
   for (; idx < 4; ++idx, ++s) {
@@ -418,6 +451,9 @@ void CDSPStream::ReadCompleted(s32, DVDFileInfo* fileInfo) {
     }
   }
 
+#if defined(TARGET_PC)
+  if (idx == 4) return;
+#endif
   CDSPStream& stream = g_Streams[idx];
   stream.xec_readsPending--;
   if (stream.xec_readsPending != 0) {

src/Kyoto/Audio/CDSPStreamManager.cpp

@@ -9,6 +9,10 @@
 
 #include <string.h>
 
+#if defined(TARGET_PC)
+#include "Metaforce/Audio.hpp"
+#endif
+
 CDSPStreamManager g_Streams[4] = {CDSPStreamManager(), CDSPStreamManager(), CDSPStreamManager(),
                                   CDSPStreamManager()};
 static int sHandleCounter;
@@ -64,14 +68,36 @@ bool CDSPStreamManager::StartHeaderRead(DVDCallback callback) {
   return true;
 }
 
-bool CDSPStreamManager::HasSupportedSampleRate() { return x0_header.x8_sampleRate == 32000; }
+bool CDSPStreamManager::HasSupportedSampleRate() {
+#if defined(TARGET_PC)
+  return x0_header.x8_sampleRate > 0 && x0_header.x8_sampleRate <= 65535;
+#else
+  return x0_header.x8_sampleRate == 32000;
+#endif
+}
 
 void CDSPStreamManager::WaitForReadCompletion() {
+#if defined(TARGET_PC)
+  BOOL ints = OSEnableInterrupts();
+  for (;;) {
+    bool complete;
+    {
+      metaforce::AudioLockGuard lock;
+      complete = x70_26_headerReadState != kHRS_Reading;
+    }
+    if (complete) {
+      OSRestoreInterrupts(ints);
+      return;
+    }
+    OSYieldThread();
+  }
+#else
   BOOL ints = OSEnableInterrupts();
   while (x70_26_headerReadState == 1) {
     OSYieldThread();
   }
   OSRestoreInterrupts(ints);
+#endif
 }
 
 CDSPStreamManager& CDSPStreamManager::operator=(const CDSPStreamManager& other) {
@@ -88,6 +114,13 @@ void CDSPStreamManager::Initialize() {
 }
 
 void CDSPStreamManager::Shutdown() {
+#if defined(TARGET_PC)
+  {
+    metaforce::AudioLockGuard lock;
+    for (auto& stream : g_Streams) stream.x70_25_headerReadCancelled = true;
+  }
+  for (auto& stream : g_Streams) stream.WaitForReadCompletion();
+#endif
   CDSPStream::FreeAllStreams();
   for (int i = 0; i < 4; ++i) {
     g_Streams[i] = CDSPStreamManager();
@@ -312,12 +345,24 @@ CDSPStreamManager::EState CDSPStreamManager::GetStreamState(int handle) {
 }
 
 void CDSPStreamManager::HeaderReadComplete(s32 result, DVDFileInfo* fileInfo) {
+#if defined(TARGET_PC)
+  metaforce::AudioLockGuard lock;
+#endif
   DVDClose(fileInfo);
 
   for (int idx = 0; idx < 4; ++idx) {
     CDSPStreamManager* stream = &g_Streams[idx];
     if (&stream->x80_dvdFile == fileInfo && !stream->x70_24_unclaimed) {
       CInterruptGuard interrupts;
+#if defined(TARGET_PC)
+      if (result != 0x60 || !metaforce::ReadDSPHeader(
+              {reinterpret_cast<const u8*>(&stream->x0_header), 0x60}, stream->x0_header) ||
+          fileInfo->length < 0x60 ||
+          (u64(stream->x0_header.x4_numNibbles) + 1) / 2 > fileInfo->length - 0x60) {
+        *stream = CDSPStreamManager();
+        return;
+      }
+#endif
       if (result <= 0 || !stream->HasSupportedSampleRate()) {
         *stream = CDSPStreamManager();
         return;

src/Kyoto/Audio/CMidiManager.cpp

@@ -6,9 +6,24 @@
 #include <Kyoto/CFactoryFnReturn.hpp>
 #include <Kyoto/Streams/CInputStream.hpp>
 
+#if defined(TARGET_PC)
+#include "Metaforce/Audio.hpp"
+#include "Metaforce/Common.hpp"
+
+namespace {
+constexpr borealis::Log Log{"CMidiManager"};
+}
+#endif
+
 rstl::reserved_vector< CMidiManager::CMidiWrapper, 3 > CMidiManager::mMidiWrappers;
 
-CMidiManager::CMidiWrapper::CMidiWrapper() : x0_sysHandle(0), xa_available(true) {}
+CMidiManager::CMidiWrapper::CMidiWrapper()
+: x0_sysHandle(0)
+#if defined(TARGET_PC)
+, x8_songId(-1)
+#endif
+, xa_available(true) {
+}
 
 const CSfxHandle& CMidiManager::CMidiWrapper::GetManagerHandle() const { return x4_midiHandle; }
 
@@ -39,6 +54,11 @@ CSfxHandle CMidiManager::Play(const CMidiData& data, unsigned short fadeTime, bo
   wrapper.SetMidiHandle(handle);
   if (stopExisting) {
     for (int i = 0; i < mMidiWrappers.size(); ++i) {
+#if defined(TARGET_PC)
+      if (&mMidiWrappers[i] == &wrapper) {
+        continue;
+      }
+#endif
       if (mMidiWrappers[i].IsAvailable()) {
         continue;
       }
@@ -57,7 +77,14 @@ CSfxHandle CMidiManager::Play(const CMidiData& data, unsigned short fadeTime, bo
     wrapper.SetAudioSysHandle(sysHandle);
     wrapper.SetSongId(data.GetSongId());
   } else {
-    u32 sysHandle = CAudioSys::SeqPlayEx(data.GetGroupId(), data.GetSongId(), data.GetData(), nullptr, 0);
+    u32 sysHandle =
+        CAudioSys::SeqPlayEx(data.GetGroupId(), data.GetSongId(), data.GetData(), nullptr, 0);
+#if defined(TARGET_PC)
+    if (sysHandle == SND_ID_ERROR) {
+      wrapper.SetAvailable(true);
+      return {};
+    }
+#endif
     if (fadeTime != 0) {
       CAudioSys::SeqVolume(0, 0, sysHandle, 0);
     }
@@ -113,15 +140,33 @@ CSfxHandle CMidiManager::LocateHandle() {
 
 CMidiManager::CMidiData::CMidiData(CInputStream& in)
 : x0_songId(-1), x2_groupId(-1), x4_agscId(-1) {
+#if defined(TARGET_PC)
+  u8 bytes[20];
+  metaforce::AudioSongHeader header{};
+  REQUIRE(in.ReadBytes(bytes, sizeof(bytes)) == sizeof(bytes) &&
+              metaforce::ReadAudioSongHeader(bytes, header),
+          "Invalid CSNG header");
+  x0_songId = header.song;
+  x2_groupId = header.group;
+  x4_agscId = header.audioGroup;
+  x8_data = rs_new uchar[header.length];
+  REQUIRE(in.ReadBytes(x8_data.get(), header.length) == header.length,
+          "Truncated CSNG arrangement");
+  SND_PC_ASSET_ERROR error{};
+  REQUIRE(sndPCValidateArrangement({x8_data.get(), header.length}, &error),
+          "Invalid CSNG arrangement at {}: {}", error.offset, error.reason ? error.reason : "");
+#else
   in.ReadLong();
   x0_songId = in.ReadLong();
   x2_groupId = in.ReadLong();
   x4_agscId = in.ReadLong();
   int len = in.ReadInt32();
   x8_data = rs_new uchar[len];
   in.Get(x8_data.get(), len);
+#endif
 }
 
-const CFactoryFnReturn FMidiDataFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer&) {
+const CFactoryFnReturn FMidiDataFactory(const SObjectTag& tag, CInputStream& in,
+                                        const CVParamTransfer&) {
   return rs_new CMidiManager::CMidiData(in);
 }