Retune the original Taiko kit for arcade punch

README.md

@@ -29,8 +29,9 @@ The Space uses Gradio Server mode with a fully custom, responsive interface.
 Upload a song, pick a difficulty, and get a full-song mel/plan preview, a
 full TJA chart image, a `.tja` playable in TJAPlayer3 / OpenTaiko, and a
 synchronized WAV mix that lets you hear the generated chart performed over
-the source music immediately. The game-style wadaiko kit is synthesized by
-SoftChart and does not contain audio taken from a commercial game.
+the source music immediately. The original, arcade-tuned wadaiko kit is
+synthesized by SoftChart and does not contain audio taken from a commercial
+game.
 
 The generation API streams the real processing stages to the interface:
 audio analysis, beat-grid fitting, song-level planning, note generation,

softchart/preview_audio.py

@@ -236,73 +236,85 @@ def _falling_mode(t: np.ndarray, start_hz: float, end_hz: float,
     return np.sin(phase) * np.exp(-t / decay)
 
 
-def _add_reflection(signal: np.ndarray, sample_rate: int, delay_seconds: float,
-                    gain: float) -> None:
-    delay = max(1, int(round(delay_seconds * sample_rate)))
-    if delay < len(signal):
-        signal[delay:] += gain * signal[:-delay]
+def _highpass(signal: np.ndarray, sample_rate: int, cutoff_hz: float) -> np.ndarray:
+    sos = butter(2, cutoff_hz, btype="highpass", fs=sample_rate, output="sos")
+    return sosfilt(sos, signal).astype(np.float64)
+
+
+def _soft_clip(signal: np.ndarray, drive: float) -> np.ndarray:
+    """Compress peaks while keeping the small-signal gain at unity."""
+
+    return np.tanh(signal * drive) / drive
 
 
 def _make_don(sample_rate: int, variant: int, big: bool = False,
               tap: bool = False) -> np.ndarray:
-    duration = 0.19 if tap else (0.62 if big else 0.43)
+    # Compact arcade feedback needs the mid-bass membrane cluster and bachi
+    # attack to survive small speakers.  The frequencies are based on measured
+    # wadaiko mode relationships, deliberately omitting kick-like sub-bass and
+    # the large downward pitch sweep used by the previous voice.
+    duration = 0.105 if tap else (0.29 if big else 0.27)
     n = int(round(duration * sample_rate))
     t = np.arange(n, dtype=np.float64) / sample_rate
     rng = np.random.default_rng(12_710 + 101 * variant + 1_009 * int(big) + 7_003 * int(tap))
-    pitch = (0.965, 0.985, 1.010, 1.030)[variant % 4] * (0.84 if big else 1.0)
-    if tap:
-        pitch *= 1.10
-    attack = 1.0 - np.exp(-t / 0.00075)
+    pitch = (0.982, 0.994, 1.008, 1.019)[variant % 4]
+    attack = 1.0 - np.exp(-t / 0.00024)
 
     modes = np.zeros(n, dtype=np.float64)
-    frequencies = (104.0, 166.0, 248.0, 362.0)
-    weights = (1.00, 0.54, 0.31, 0.17)
-    decays = (0.27, 0.19, 0.125, 0.080)
-    decay_scale = 0.55 if tap else (1.35 if big else 1.0)
+    frequencies = (255.0, 295.0, 560.0, 690.0, 1_015.0)
+    weights = (0.82, 1.00, 0.47, 0.32, 0.17)
+    decays = (0.185, 0.165, 0.095, 0.068, 0.040)
+    decay_scale = 0.31 if tap else (1.06 if big else 1.0)
     for frequency, weight, decay in zip(frequencies, weights, decays):
         end_hz = frequency * pitch
         modes += weight * _falling_mode(
-            t, end_hz * (1.24 + 0.015 * variant), end_hz,
-            0.017 if tap else 0.026, decay * decay_scale,
+            t, end_hz * (1.012 + 0.002 * variant), end_hz,
+            0.009, decay * decay_scale,
         )
 
-    skin = _filtered_noise(rng, n, sample_rate, 150.0, 3_600.0)
-    skin *= np.exp(-t / (0.012 if tap else 0.021))
-    stick = _filtered_noise(rng, n, sample_rate, 900.0, 7_200.0)
-    stick *= np.exp(-t / 0.0045)
-    signal = attack * modes + 0.26 * skin + 0.075 * stick
-    if big:
-        signal += 0.34 * _falling_mode(t, 89.0, 66.0, 0.038, 0.38)
-    _add_reflection(signal, sample_rate, 0.0083, 0.075 if tap else 0.11)
-    _add_reflection(signal, sample_rate, 0.0171, 0.035 if tap else 0.065)
-    signal *= np.exp(-np.maximum(t - duration * 0.78, 0.0) / 0.035)
-    target = 0.43 if tap else (0.94 if big else 0.78)
+    skin = _filtered_noise(rng, n, sample_rate, 380.0, 5_400.0)
+    skin *= np.exp(-t / (0.0042 if tap else 0.0075))
+    stick = _filtered_noise(rng, n, sample_rate, 1_300.0, 9_500.0)
+    stick *= np.exp(-t / 0.0018)
+    signal = (
+        attack * modes
+        + (0.30 if tap else 0.20) * skin
+        + (0.17 if tap else 0.105) * stick
+    )
+    signal = _highpass(signal, sample_rate, 115.0 if tap else 62.0)
+    signal = _soft_clip(signal, 1.42)
+    signal *= np.exp(-np.maximum(t - duration * 0.72, 0.0) / 0.018)
+    target = 0.59 if tap else (0.90 if big else 0.84)
     signal *= target / max(float(np.max(np.abs(signal))), 1e-12)
     return signal.astype(np.float32)
 
 
 def _make_ka(sample_rate: int, variant: int, big: bool = False) -> np.ndarray:
-    duration = 0.35 if big else 0.25
+    # Ka is a dry wooden rim crack: a millisecond-scale excitation followed by
+    # short, irregular high modes.  Broadband noise is only the bachi contact,
+    # not the body of the sound.
+    duration = 0.16 if big else 0.14
     n = int(round(duration * sample_rate))
     t = np.arange(n, dtype=np.float64) / sample_rate
     rng = np.random.default_rng(37_901 + 131 * variant + 2_003 * int(big))
-    pitch = (0.970, 0.992, 1.015, 1.035)[variant % 4] * (0.90 if big else 1.0)
-    attack = 1.0 - np.exp(-t / 0.00035)
+    pitch = (0.981, 0.995, 1.009, 1.021)[variant % 4]
+    attack = 1.0 - np.exp(-t / 0.00016)
 
-    rim = _filtered_noise(rng, n, sample_rate, 620.0, 9_200.0)
-    rim *= np.exp(-t / (0.024 if big else 0.016))
+    rim = _filtered_noise(rng, n, sample_rate, 1_200.0, 10_500.0)
+    rim *= np.exp(-t / 0.0028)
     modes = np.zeros(n, dtype=np.float64)
     for frequency, weight, decay in (
-        (535.0, 0.48, 0.105), (885.0, 0.36, 0.074),
-        (1_410.0, 0.27, 0.050), (2_270.0, 0.16, 0.032),
+        (650.0, 0.42, 0.064), (1_050.0, 1.00, 0.048),
+        (1_700.0, 0.63, 0.034), (2_700.0, 0.35, 0.022),
+        (4_200.0, 0.19, 0.012),
     ):
         phase = 2.0 * np.pi * frequency * pitch * t + variant * 0.31
-        modes += weight * np.sin(phase) * np.exp(-t / (decay * (1.25 if big else 1.0)))
-    signal = 0.72 * rim + attack * modes
-    _add_reflection(signal, sample_rate, 0.0047, 0.16)
-    _add_reflection(signal, sample_rate, 0.0119, 0.085 if big else 0.060)
-    signal *= np.exp(-np.maximum(t - duration * 0.72, 0.0) / 0.025)
-    target = 0.90 if big else 0.70
+        modes += weight * np.sin(phase) * np.exp(-t / (decay * (1.04 if big else 1.0)))
+    signal = 0.22 * rim + attack * modes
+    signal = _highpass(signal, sample_rate, 390.0)
+    signal = _soft_clip(signal, 1.28)
+    signal *= np.exp(-np.maximum(t - duration * 0.68, 0.0) / 0.012)
+    target = 0.91 if big else 0.79
     signal *= target / max(float(np.max(np.abs(signal))), 1e-12)
     return signal.astype(np.float32)
 
@@ -332,13 +344,13 @@ def _expand_strikes(events: list[TaikoEvent]) -> tuple[list[_Strike], int]:
     ordinary_index = 0
     for event in events:
         if event.kind in {"don", "ka", "don_big", "ka_big"}:
-            if event.kind == "ka":
-                pan = -0.28 if ordinary_index % 2 == 0 else 0.28
-            elif event.kind == "ka_big":
-                pan = -0.10 if ordinary_index % 2 == 0 else 0.10
+            if event.kind.endswith("_big"):
+                pan = -0.35 if ordinary_index % 2 == 0 else 0.35
+            elif event.kind == "ka":
+                pan = -0.14 if ordinary_index % 2 == 0 else 0.14
             else:
-                pan = -0.035 if ordinary_index % 2 == 0 else 0.035
-            depth = 0.20 if event.kind.endswith("_big") else 0.145
+                pan = -0.02 if ordinary_index % 2 == 0 else 0.02
+            depth = 0.30 if event.kind.endswith("_big") else 0.22
             strikes.append(_Strike(event.time, event.kind, pan, depth, False))
             ordinary_index += 1
             continue
@@ -401,7 +413,7 @@ def _load_stereo_audio(audio_path: str, sample_rate: int) -> np.ndarray:
 
 
 def _place_strike(drums: np.ndarray, sample: np.ndarray, strike: _Strike,
-                  sample_rate: int) -> bool:
+                  sample_rate: int, layered_sample: np.ndarray | None = None) -> bool:
     start = int(round(strike.time * sample_rate))
     sample_start = max(0, -start)
     output_start = max(0, start)
@@ -415,26 +427,33 @@ def _place_strike(drums: np.ndarray, sample: np.ndarray, strike: _Strike,
     drums[output_start:output_start + count, 0] += segment * left_gain
     drums[output_start:output_start + count, 1] += segment * right_gain
 
-    # A quiet, opposite-side early reflection creates believable width while
-    # preserving a precise, dry transient at the chart time.
-    reflection_delay = int(round(0.011 * sample_rate))
-    reflected_start = output_start + reflection_delay
-    reflected_count = min(count, len(drums) - reflected_start)
-    if reflected_count > 0:
-        reflected = segment[:reflected_count] * 0.095
-        drums[reflected_start:reflected_start + reflected_count, 0] += reflected * right_gain
-        drums[reflected_start:reflected_start + reflected_count, 1] += reflected * left_gain
+    # A big note represents both hands, not a lower-pitched or longer drum.
+    # Layer an independently synthesized variant on the opposite side a few
+    # milliseconds later while keeping the first transient exactly on-grid.
+    if layered_sample is not None:
+        layer_delay = int(round(0.0018 * sample_rate))
+        layer_start = output_start + layer_delay
+        layer_source_start = sample_start
+        layer_count = min(
+            len(layered_sample) - layer_source_start,
+            len(drums) - layer_start,
+        )
+        if layer_count > 0:
+            layer = layered_sample[layer_source_start:layer_source_start + layer_count]
+            layer_gain = 0.72 if strike.kind == "roll_big" else 0.92
+            drums[layer_start:layer_start + layer_count, 0] += layer * right_gain * layer_gain
+            drums[layer_start:layer_start + layer_count, 1] += layer * left_gain * layer_gain
     return True
 
 
 def _duck_envelope(frame_count: int, strikes: list[_Strike], sample_rate: int,
                    drum_gain: float) -> tuple[np.ndarray, float]:
     reduction = np.zeros(frame_count, dtype=np.float32)
-    attack_frames = max(1, int(round(0.006 * sample_rate)))
-    release_frames = max(1, int(round(0.115 * sample_rate)))
+    attack_frames = max(1, int(round(0.0025 * sample_rate)))
+    release_frames = max(1, int(round(0.080 * sample_rate)))
     attack = 0.5 - 0.5 * np.cos(np.linspace(0.0, np.pi, attack_frames, dtype=np.float32))
     release = np.exp(-np.arange(release_frames, dtype=np.float32) /
-                     max(1.0, 0.042 * sample_rate))
+                     max(1.0, 0.027 * sample_rate))
     shape = np.concatenate((attack, release))
     gain_scale = min(drum_gain / 0.8, 1.0) if drum_gain > 0.0 else 0.0
 
@@ -450,7 +469,7 @@ def _duck_envelope(frame_count: int, strikes: list[_Strike], sample_rate: int,
         target = reduction[output_start:output_start + count]
         np.maximum(target, envelope, out=target)
 
-    np.minimum(reduction, 0.32, out=reduction)
+    np.minimum(reduction, 0.38, out=reduction)
     gain = 1.0 - reduction
     max_duck_db = -20.0 * math.log10(max(float(np.min(gain)), 1e-12))
     return gain, max_duck_db
@@ -466,6 +485,16 @@ def _write_pcm16_wav(out_path: str, pcm: np.ndarray, sample_rate: int) -> None:
         wav.writeframes(np.ascontiguousarray(pcm.astype("<i2", copy=False)).tobytes())
 
 
+def _soft_limit(signal: np.ndarray, threshold: float, ceiling: float) -> np.ndarray:
+    """Limit only hot samples instead of turning down the entire preview."""
+
+    magnitude = np.abs(signal)
+    width = ceiling - threshold
+    over = np.maximum(magnitude - threshold, 0.0) / width
+    shaped = threshold + width * np.tanh(over)
+    return np.copysign(np.where(magnitude <= threshold, magnitude, shaped), signal)
+
+
 def synthesize_taiko_preview(
     audio_path: str,
     tja_text: str,
@@ -475,9 +504,9 @@ def synthesize_taiko_preview(
 ) -> dict[str, float | int]:
     """Mix a synchronized stereo PCM16 WAV preview and return numeric stats.
 
-    Music is held at 2 dB of mix headroom and briefly ducked under each drum
-    transient.  The final mix uses transparent global peak reduction when
-    needed and is quantized below a -1 dBFS sample-peak ceiling.
+    Music is held at 3.5 dB of mix headroom and briefly ducked under each drum
+    transient.  A local soft limiter controls only hot samples before PCM16
+    quantization at a -1 dBFS sample-peak ceiling.
     """
 
     if not isinstance(sample_rate, int) or sample_rate < 16_000 or sample_rate > 192_000:
@@ -507,21 +536,28 @@ def synthesize_taiko_preview(
     for index, strike in enumerate(strikes):
         samples = bank[strike.kind]
         sample = samples[index % len(samples)]
-        if _place_strike(drums, sample, strike, sample_rate):
+        layered_sample = None
+        if strike.kind in {"don_big", "ka_big", "roll_big"}:
+            layered_sample = samples[(index + 1) % len(samples)]
+        if _place_strike(
+            drums, sample, strike, sample_rate, layered_sample=layered_sample,
+        ):
             audible_strikes.append(strike)
 
+    drums = _soft_clip(drums, 1.10).astype(np.float32)
     duck_gain, max_duck_db = _duck_envelope(
         len(music), audible_strikes, sample_rate, drum_gain,
     )
-    music_gain = 10.0 ** (-2.0 / 20.0)
+    music_gain = 10.0 ** (-3.5 / 20.0)
     mixed = music * (music_gain * duck_gain[:, None])
     mixed += drums * float(drum_gain)
 
     pre_limit_peak = float(np.max(np.abs(mixed))) if mixed.size else 0.0
     float_ceiling = _PCM16_CEILING / 32767.0
-    limiter_gain = min(1.0, float_ceiling / pre_limit_peak) if pre_limit_peak > 0.0 else 1.0
-    mixed *= limiter_gain
+    mixed = _soft_limit(mixed, threshold=0.68, ceiling=float_ceiling)
     np.clip(mixed, -float_ceiling, float_ceiling, out=mixed)
+    limited_peak = float(np.max(np.abs(mixed))) if mixed.size else 0.0
+    limiter_gain = min(1.0, limited_peak / pre_limit_peak) if pre_limit_peak > 0.0 else 1.0
     pcm = np.rint(mixed * 32767.0).astype(np.int16)
     _write_pcm16_wav(out_path, pcm, sample_rate)