arcattackandClaude Opus 5
d39227ef39
SAURON's "coolant flush sound glitched and perma" is one instance of a systemic
defect. SetupPatch (L4AUDLVL.cpp) decided looping from the SAMPLE flag alone:
AL_LOOPING = (info.loop != ForceStatic)
That armed every non-ForceStatic sample -- 224 of the 603 authored zones,
including unmistakable one-shots -- as an OpenAL source that never ends on its
own. Any such sound whose note-off never arrives plays forever. Measured 1946
LoopAtWill x Transient arming events in one short session.
The sample flag expresses PERMISSION; the SOURCE decides. Three facts [T1]:
* the enum's own comments (L4AUDLVL.h:14-19) -- LoopAtWill = "will play once
OR LOOP AS DESIRED", ForceStatic = "plays only once EVEN IF LOOPED" (a
veto), LoopAlways = "ramp up and then down";
* LoopAtWill is enum value 0, i.e. the DEFAULT an unauthored sample receives
(WTPresets.cpp:37) -- it cannot mean "loop forever";
* LoopAlways, the real always-loop, is used by ZERO shipped samples.
"As desired" is the source's authored AudioRenderType (Transient=one-shot vs
Sustained=held), streamed from AUDIO*.RES (AUDLVL.cpp:28) and already consulted
by the renderer (L4AUDRND.cpp:567, AUDREND.cpp:184). SetupPatch now takes it,
threaded from all three L4AudioSource call sites (Direct/Dynamic3D/Static3D).
New rule: LoopAlways->1, ForceStatic->0, LoopAtWill->the source's render type.
MEASURED before changing behaviour (BT_LOOP_AUDIT=1, scratchpad/loopaudit.py):
LoopAtWill x Transient -> loop=0 (was 1) 1946 events
LoopAtWill x Sustained -> loop=1 unchanged 65 events
ForceStatic x Transient -> loop=0 unchanged 292 events
The engine loops (EngineAccel07_z0..z2, EngineMotor01, EnginePower01) are all
LoopAtWill/Sustained and PRESERVED -- no regression there. All 24 reclassified
samples are genuine one-shots: laser charge/fire/explosion/loaded, missile
loading, engine shift, coolant pressure inc/dec.
A/B PROOF (scratchpad/loopab.py, same session both arms, only BT_LOOP_LEGACY
differs), asking the engine's own BT_AUDIO_DUMP what is still playing with
loop=1 long after every release:
[legacy] EnginePower01, CoolantPresInc03_z2, CoolantPresDcr03_z2
[fixed] EnginePower01
The two stuck coolant sources are the reported symptom. They were eventually
reclaimed when a later trigger reused the source, which is why the bug was
intermittent -- the "perma" case is when nothing else retriggers it. The fix
removes the mechanism.
BT_LOOP_LEGACY=1 restores the old rule for a field A/B without a rebuild. The
layers to listen to are the beam sustains: LaserA/CSustain* are authored
LoopAtWill on a TRANSIENT source, so they now end with the sample instead of
looping until note-off. The render type is T1 authored data; the interpretation
that LoopAtWill defers to it is a strong reading of the enum + defaults rather
than a disassembled statement, and is flagged as such in the KB.
Plausibly bears on #32 (audio cutting in/out late in a match): a stuck looping
source holds its pool slot for the rest of the round.
Rigs: scratchpad/flushsnd.py (flush start/stop pairing), flushsnd2.py (stuck-
source hunt), loopaudit.py (the classification matrix), loopab.py (the A/B).
KB: context/wintesla-port.md audio section, context/decomp-reference.md env
table (BT_LOOP_AUDIT / BT_LOOP_LEGACY / BT_AUDIO_DUMP / BT_AUD_TAIL),
docs/AUDIO_FIDELITY.md F38. checkctx.py CLEAN.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
114 lines
4.0 KiB
Python
114 lines
4.0 KiB
Python
"""Reproduce Gitea #51 -- the coolant flush sound loops forever (SAURON, night 3).
|
|
|
|
Uses the built-in scripted flush (BT_FLUSH_TEST=<frame>): holds the flush for ~60
|
|
sim frames, then releases. Instruments all four layers of the chain so the stuck
|
|
stage is identifiable rather than guessed:
|
|
|
|
[flush-tx] the input dispatch edge (mech4.cpp:5566 -- PRESS / RELEASE pair)
|
|
[flush] the reservoir drain (heatfamily_reslice.cpp:772, while alarm==1)
|
|
[aud-tail] OpenAL PLAY / STOP per source, with the LoopAtWill flag + release time
|
|
[audio] PlayNote / StopNote calls
|
|
|
|
PASS = one PRESS + one RELEASE, the [flush] drain STOPS after the release, and every
|
|
CoolantDump source that got a PLAY also gets a STOP. A stuck sound shows up as
|
|
either repeated PLAY lines with no STOP (per-frame re-trigger -- PlayNote restarts
|
|
any source not currently AL_PLAYING) or a PLAY with no matching STOP at all.
|
|
|
|
Runs well past the release so a late re-trigger is visible. Kills only its own PID.
|
|
"""
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
REPO = r"C:\git\bt411"
|
|
LOG = os.path.join(REPO, "scratchpad_flushsnd.log")
|
|
if os.path.exists(LOG):
|
|
os.remove(LOG)
|
|
|
|
env = dict(os.environ)
|
|
env.update({
|
|
"BT_START_INSIDE": "1",
|
|
"BT_DEV_GAUGES": "1",
|
|
"BT_FLUSH_TEST": "300", # press at sim frame 300, release 60 frames later
|
|
"BT_FLUSH_LOG": "1",
|
|
"BT_AUD_TAIL": "1",
|
|
"BT_AUDIO_LOG": "1",
|
|
"BT_LOG": LOG,
|
|
})
|
|
proc = subprocess.Popen(
|
|
[os.path.join(REPO, "build", "Release", "btl4.exe"), "-egg", "LAST.EGG"],
|
|
cwd=os.path.join(REPO, "content"), env=env,
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
print("pid", proc.pid)
|
|
|
|
try:
|
|
deadline = time.time() + 260
|
|
released = False
|
|
while time.time() < deadline:
|
|
if os.path.exists(LOG):
|
|
t = open(LOG, errors="replace").read()
|
|
if "[flush-tx] InjectCoolant RELEASE" in t:
|
|
released = True
|
|
break
|
|
time.sleep(2)
|
|
# keep running well past the release -- a late re-trigger is the whole point
|
|
time.sleep(20)
|
|
finally:
|
|
proc.terminate()
|
|
time.sleep(1)
|
|
|
|
t = open(LOG, errors="replace").read() if os.path.exists(LOG) else ""
|
|
tx = re.findall(r"^\[flush-tx\].*$", t, re.M)
|
|
drain = re.findall(r"^\[flush\].*$", t, re.M)
|
|
tail = re.findall(r"^\[aud-tail\].*$", t, re.M)
|
|
|
|
# pair PLAY/STOP per source, and flag which sources carry the LoopAtWill flag
|
|
plays, stops, loopy = {}, {}, set()
|
|
for l in tail:
|
|
m = re.search(r"(PLAY|STOP) src=(\d+).*?file=(\S+)", l)
|
|
if not m:
|
|
continue
|
|
kind, src, f = m.group(1), m.group(2), m.group(3)
|
|
(plays if kind == "PLAY" else stops).setdefault((src, f), 0)
|
|
(plays if kind == "PLAY" else stops)[(src, f)] += 1
|
|
if kind == "PLAY" and "loop=1" in l:
|
|
loopy.add((src, f))
|
|
|
|
print("\n=============== RESULT ===============")
|
|
print("reached the release edge:", released)
|
|
print("\n[flush-tx] dispatch edges:", len(tx))
|
|
for l in tx:
|
|
print(" ", l[:120])
|
|
|
|
print("\n[flush] drain samples:", len(drain), "(should stop at the release)")
|
|
for l in drain[:4]:
|
|
print(" ", l[:120])
|
|
if len(drain) > 4:
|
|
print(" ... last:", drain[-1][:120])
|
|
|
|
print("\nOpenAL source pairing (coolant layers only):")
|
|
allk = sorted(set(plays) | set(stops))
|
|
unbalanced = []
|
|
for k in allk:
|
|
if "Coolant" not in k[1] and "coolant" not in k[1]:
|
|
continue
|
|
p, s = plays.get(k, 0), stops.get(k, 0)
|
|
flag = " LoopAtWill" if k in loopy else ""
|
|
print(" src=%-5s %-28s PLAY=%d STOP=%d%s" % (k[0], k[1], p, s, flag))
|
|
if p > s:
|
|
unbalanced.append((k, p, s))
|
|
|
|
print("\nTotal [aud-tail] lines:", len(tail))
|
|
if unbalanced:
|
|
print("\n*** UNBALANCED (sound left running / re-triggered):")
|
|
for k, p, s in unbalanced:
|
|
print(" %s %s PLAY=%d STOP=%d" % (k[0], k[1], p, s))
|
|
|
|
verdict = ("REPRODUCED -- a coolant source plays more than it stops" if unbalanced
|
|
else ("clean pairing this run -- flush start/stop balanced" if tail
|
|
else "NO [aud-tail] output -- audio path never fired (check the rig)"))
|
|
print("\nVERDICT:", verdict)
|
|
sys.exit(0)
|