audio fix v2

Author: TalhaMudo

PROJECT.md

@@ -1216,6 +1216,14 @@ chatty renderer (~1250 draws, ~62 thousand COM calls per frame).
 | `MOUSEAT=x,y[@frame,x,y]` | pin the cursor position the game sees (cursor mapping test) |
 | `NOFOCUS=1` | open the window in the background, don't steal focus (testing while the user works) |
 | `NOSOUND=1` | no sound output |
+| `NFSU2_SLEEP_OLD=1` | the game's `Sleep`/timer back on `nanosleep` at default QoS, and every sound fix below off (issue #12 A/B) |
+| `NFSU2_CATCHUP=0` | no timer catch-up / counted timer wake-ups / sleep debt |
+| `NFSU2_PACE=0` | the sound loops read the virtual clock again (they stand still in long frames) |
+| `NFSU2_GILPRIO=0` | no big-lock priority for the sound threads |
+| `NFSU2_IOYIELD=0` | large file reads keep the big lock |
+| `SLEEPSLACK=<us>` | measurement: every game `Sleep` / timer sleep wakes this much later |
+| `GILHOG=<ms>:<ms>` | measurement: the game thread keeps the lock for the first value every second value, re-taking it every 50 us |
+| `READSLOW=<us>` | measurement: every file read of 16 KB or more takes this much longer |
 | `NORTFREE=1` | turn off releasing old render targets on Reset (diagnostic) |
 | `NORTRESET=1` | don't return the target/Z to the back buffer on Reset (old behavior; the car breaks) |
 | `NORSRESET=1` | don't reset render/sampler/stage states to defaults on Reset (old behavior) |
@@ -2204,3 +2212,39 @@ frame 1650); the headlight lenses are draws 213-222 (light atlas texture 813,
 64x64, complete with 4 mips; 807 = tail lights); the highlight itself is the
 scene's reflection on the body panels, not a missing texture and not post
 processing. Not decided whether anything is wrong without a reference image.
+
+## 2026-11-02 – 11-03: audio dropouts (issue #12)
+
+Reports: the sound "is gone for a second" every few seconds, on several Macs, not
+reproducible here. The reporter's log (M6, 60 Hz, NA HD): the sound service timer
+ran at 32 ticks a second instead of 100, the music buffer got 130 KB/s for 176 KB/s
+played, 28% of the output was silence, 99 cursor overruns, 8 s of silence while a
+race loaded. The game's sound hangs on two 100 Hz loops: the DirectSound mixer thread
+(`0x7263c7`, `THREAD_PRIORITY_TIME_CRITICAL`: `next += 10`, `Sleep(next - now)`) and
+the sound service timer (`0x6f5b4d`, a one-shot `timeSetEvent` that re-arms itself
+and `SetEvent`s the service thread, `THREAD_PRIORITY_HIGHEST`). Four causes, all in
+`runtime/win32_ext.c` (+ `win32.c`, `fileio.c`, `dispatch.c`, `com.c`):
+
+1. **Sleeps.** `Sleep` and the timer thread used `nanosleep`, which macOS coalesces,
+   and the game's threads ran at `QOS_CLASS_DEFAULT` (`pthread_create` does not
+   inherit QoS). Now `kevent NOTE_CRITICAL` and `USER_INTERACTIVE`. Under full CPU
+   load: late wake-ups 0.9 ms average / 25 ms max -> 0.03 / 2 ms.
+2. **Late wake-ups lost ticks.** A timer re-armed for <= 1 ms (behind schedule)
+   fires again at once; a `SetEvent` from the timer thread counts (up to 16);
+   `Sleep` repays lateness (sleep debt). `SLEEPSLACK=55000`: 17 -> 100 ticks a
+   second, silence 9.7% -> 2.9% (2.7% without the slack).
+3. **The virtual clock stood still in long frames** (50 ms cap), and so did both
+   loops. Their 7 clock reads (return addresses) now see real time and the timers
+   are due in real time (SOUND PACE CLOCK, `win32.c`). Large file reads also give
+   the big lock up.
+4. **The big lock.** The macOS mutex is unfair; the game thread re-takes it thousands
+   of times a second. The sound threads (game priority >= 2) and the timer thread now
+   come first: others step back, the holder hands over at its next Win32, COM or
+   indirect call. Reproduced here: a 656 ms hold while a race loaded, 950 ms muted,
+   20 overruns (2 of ~12 runs); with priority the sound threads waited at most
+   10-24 ms, no dropouts in 5 runs, frame times unchanged.
+
+The log now carries `[timer]` lines every 30 s (tick rate, late wake-ups, lock waits,
+catch-up and lost ticks). Note for measurements: "sound data gaps" also counts the
+silence of loading screens; use the stale guard and cursor overrun lines. Left: a
+230-330 ms hold at start-up, before any sound plays (inaudible).

README.md

@@ -352,6 +352,13 @@ Yes, without Windows: `tools/install_from_discs.py` unpacks the disc images
 into a game folder. See [Installing from the PC discs on a
 Mac](#installing-from-the-pc-discs-on-a-mac).
 
+**The sound cuts out for a moment every few seconds.**
+Fixed after v2.2: the game's two sound loops depend on waking up every 10 ms, and
+macOS woke them late or let the game's main thread keep them waiting (see
+`PROJECT.md`, "audio dropouts"). If it still happens, please attach
+`~/Library/Logs/NFSU2/nfsu2.log` (`nfsu2-hd.log` for HD) to an issue: its
+`[timer]` lines show which part is late.
+
 **Does it work on Intel Macs?**
 No. Only Apple Silicon is targeted and tested.
 

runtime/build_na.h

@@ -141,6 +141,13 @@
 #define GA_0x669fa6u 0x00669f96u   /* function 00669f40 + 0x66 */
 #define GA_0x669fe5u 0x00669fd5u   /* function 00669fc3 + 0x22 */
 #define GA_0x66d8afu 0x0066d89fu   /* function 0066d7e9 + 0xc6 */
+#define GA_0x6f5b94u 0x006f5b94u   /* function 006f5b4d + 0x47 */
+#define GA_0x6f5bacu 0x006f5bacu   /* function 006f5b4d + 0x5f */
+#define GA_0x6f5da8u 0x006f5da8u   /* function 006f5c91 + 0x117 */
+#define GA_0x7262b7u 0x007262b7u   /* function 007260f7 + 0x1c0 */
+#define GA_0x7263d9u 0x007263d9u   /* function 007263c7 + 0x12 */
+#define GA_0x726402u 0x00726402u   /* function 007263c7 + 0x3b */
+#define GA_0x726411u 0x00726411u   /* function 007263c7 + 0x4a */
 #define GA_0x7a66bcu 0x007a66b4u   /* operand pair */
 #define GA_0x7b6fe8u 0x007b6fe0u   /* operand pair */
 #define GA_0x7d7d3cu 0x007d7d3cu   /* operand pair */

runtime/com.c

@@ -2222,6 +2222,8 @@ static void tunedrag(unsigned char *ms){
 int com_call(CPU *c, uint32_t magic){
     uint32_t iface=(magic>>16)&0x1FFFu, m=magic&0xFFFFu;
     g_com_calls++;
+    /* see win32_ext.c LOCK PRIORITY: a sound thread waiting for the big lock gets it here */
+    if (!g_sb_replay){ void guest_gil_check(void); guest_gil_check(); }
     if (!g_sb_replay) POP32(c->eip);
     if (iface==0 || iface>=NEL(g_if) || m>=g_if[iface].n){
         fprintf(stderr,"  [COM] invalid interface/method %u:%u\n", iface, m);

runtime/dispatch.c

@@ -1,3 +1,4 @@
+#include <stdatomic.h>
 /* Indirect call dispatch: guest address -> lifted native function.
  * O(1) direct index table (a uint32 array the size of .text).           */
 #include "cpu.h"
@@ -77,6 +78,11 @@ void dispatch_indirect(CPU *c, uint32_t addr){
     { extern int g_efx_stat; extern void efx_stat_note(CPU *c, uint32_t addr);
       if (g_efx_stat && addr - 0x650000u < 0x40000u) efx_stat_note(c, addr); }
     uint32_t off = addr - TEXT_BASE;
+    /* win32_ext.c LOCK PRIORITY: a waiting sound thread also gets the big lock here, so a
+     * long stretch of game code without Win32 or COM calls (a load) doesn't keep it out */
+    { extern _Atomic int g_gil_prio_wait;
+      if (__builtin_expect(atomic_load_explicit(&g_gil_prio_wait, memory_order_relaxed) != 0, 0)){
+          void guest_gil_check(void); guest_gil_check(); } }
     if (off < TEXT_SIZE){
         uint32_t k = g_idx[off];
         if (k){

runtime/fileio.c

@@ -332,9 +332,26 @@ static int fileio_call_impl(CPU *c, const char *n, uint32_t *out){
         else { if(len) mem_commit(buf,len);
                ssize_t got;
                uint64_t _rd0 = now_ns_io();
+               /* READ WITHOUT THE BIG LOCK: a large read gives the big lock up while the disk
+                * works.  The game reads a race's data in multi-megabyte pieces on its main
+                * thread; on a slow disk (external drive, files iCloud has to fetch back) the
+                * sound threads couldn't run for the whole load and the music stopped (issue
+                * #12 log: 8 s).  On Windows the sound runs alongside.  The buffer is the
+                * game's own, as on Windows.  NFSU2_IOYIELD=0 keeps the lock; READSLOW=<us>
+                * (measurement) makes every large read that much slower, like a slow disk. */
+               int io_y = 0;
+               { static int yoff = -1; if (yoff < 0){ const char *e = getenv("NFSU2_IOYIELD"); yoff = e && *e == '0'; }
+                 static long slow = -1; if (slow < 0){ const char *e = getenv("READSLOW"); slow = e ? atol(e) : 0; }
+                 if (len >= 16384u){
+                     int guest_blocking_begin(void);
+                     if (!yoff) io_y = guest_blocking_begin();
+                     if (slow > 0) usleep((useconds_t)slow);
+                 } }
+               int fd = f->fd;
                if (ov && mem_is_committed(ov+19)){
                    uint64_t off = (uint64_t)MR32(ov+8) | ((uint64_t)MR32(ov+12) << 32);
-                   got = pread(f->fd, g_mem+buf, len, (off_t)off);
+                   got = pread(fd, g_mem+buf, len, (off_t)off);
+                   if (io_y){ void guest_blocking_end(void); guest_blocking_end(); io_y = 0; }
                    if(got<0) got=0;
                    MR32(ov+0) = 0;                      /* Internal = STATUS_SUCCESS */
                    MR32(ov+4) = (uint32_t)got;          /* InternalHigh = bytes read */
@@ -351,9 +368,10 @@ static int fileio_call_impl(CPU *c, const char *n, uint32_t *out){
                } else if (f->empty){
                    got = 0;                       /* immediate end of file */
                } else {
-                   got = read(f->fd, g_mem+buf, len);
+                   got = read(fd, g_mem+buf, len);
                    if(got<0) got=0;
                }
+               if (io_y){ void guest_blocking_end(void); guest_blocking_end(); io_y = 0; }
                /* MUTEFILE=<substring>: fill the reads of the matching file with ZEROS.
                 * To measure objectively whether sound effects remain once the
                 * music stream (sdat.viv) is silenced.  We don't return end of

runtime/win32.c

@@ -176,6 +176,41 @@ uint64_t host_us(void){
     return base + d + atomic_load(&g_vclock_creep);
 }
 uint32_t host_ms(void){ return (uint32_t)(host_us() / 1000ull) + 1000u; }
+
+/* ---- SOUND PACE CLOCK ---------------------------------------------------------
+ * The game's two 100 Hz sound loops time themselves with GetTickCount/timeGetTime:
+ * the sound service timer (0x6f5b4d: due += 10 ms, re-arm for due - now - 1, seeded at
+ * 0x6f5da6) and the DirectSound mixer thread (0x7263c7: next += 10 ms, Sleep(next -
+ * now); its mixer measures the time since the last pass at 0x7262b1).  The virtual
+ * clock stops at 50 ms inside a frame, so in a long frame -- a load -- both loops saw
+ * time stand still: the timer re-armed itself further and further out (10, 20, 30 ms
+ * ...) and the mixer slept up to 200 ms per pass; the music stopped for the whole load
+ * (issue #12 log: 8 s of silence while a race loaded).  On Windows these loops run on
+ * real time.  Only these call sites (their return addresses) read real time, aligned
+ * with the virtual clock at the first read; their values never meet the rest of the
+ * game's time.  NFSU2_PACE=0 turns it off. */
+int pace_on(void){
+    static int on = -1;
+    if (on < 0){ const char *e = getenv("NFSU2_PACE"), *o = getenv("NFSU2_SLEEP_OLD");
+                 on = !((e && *e == '0') || (o && *o == '1')); }
+    return on;
+}
+static int pace_site(uint32_t ra){
+    if (!pace_on()) return 0;
+    return ra == GA(0x6f5b94u) || ra == GA(0x6f5bacu) || ra == GA(0x6f5da8u) ||          /* GetTickCount */
+           ra == GA(0x7263d9u) || ra == GA(0x726402u) || ra == GA(0x726411u) || ra == GA(0x7262b7u);  /* timeGetTime */
+}
+static uint32_t pace_ms(void){
+    static _Atomic int64_t offset_us = INT64_MIN;
+    int64_t o = atomic_load(&offset_us);
+    if (o == INT64_MIN){
+        int64_t want = (int64_t)host_us() - (int64_t)real_us();
+        if (!atomic_compare_exchange_strong(&offset_us, &o, want)) o = atomic_load(&offset_us); else o = want;
+    }
+    return (uint32_t)((uint64_t)((int64_t)real_us() + o) / 1000ull) + 1000u;
+}
+uint64_t g_pace_reads = 0;
+uint32_t game_ms_at(uint32_t ra){ if (pace_site(ra)){ g_pace_reads++; return pace_ms(); } return host_ms(); }
 uint64_t host_qpc(void){ return host_us(); }
 
 /* the guest heap itself lives in gheap.c (free lists + quarantine) */
@@ -424,7 +459,7 @@ int win32_call(CPU *c, uint32_t idx){
     else if (!strcmp(n,"GetCurrentProcess"))     r = 0xffffffffu;
     else if (!strcmp(n,"GetLastError"))          r = 0;
     else if (!strcmp(n,"SetLastError"))          r = 0;
-    else if (!strcmp(n,"GetTickCount")) r = host_ms();
+    else if (!strcmp(n,"GetTickCount")) r = game_ms_at(c->eip);   /* see SOUND PACE CLOCK */
     else if (!strcmp(n,"QueryPerformanceFrequency")){ uint32_t p=ARG(c,0); if(p){MR32(p)=1000000;MR32(p+4)=0;} r=1; }
     else if (!strcmp(n,"SetUnhandledExceptionFilter")) r = 0;
     else if (!strcmp(n,"UnhandledExceptionFilter"))    r = 0;