피파 목소리는 아빠가 아니야

// frontend/src/lib/voiceTurn.ts:403-417 (cwkPippa)
/** Her voice's pitch range (todo #314, 2026-10-04). Echo cancellation lets her
 *  through at full loudness for half a second or so where she starts again
 *  after a pause: now and then in Chromium, often in a WebKit host (Cinder,
 *  Ariandel). Every phantom cut-in whose recording was kept is her own voice
 *  at 216-333 Hz (her onsets reach 330), Dad speaks at 100-180 Hz, and Scribe
 *  then wrote her words as his turn ("책상 위에는...", "응.", "네.", "안녕히
 *  계세요."). Replayed over the 116 kept recordings of a web cut since
 *  2026-09-27 (§10.3): 19 runs of her voice are turned away, the nine whose
 *  transcript proves it among them; no cut-in of Dad's is lost, and 17 land
 *  later, 10 of them by one chunk (0.13 s), none by more than 0.77 s. A soul
 *  with a low voice gets no help from this, and loses nothing. */
export const HER_REGISTER_HZ: readonly [number, number] = [205, 360];

/** Web chunks are 2048 samples at 16 kHz (128 ms): ~0.4 s of speech. */
export const WEB_BARGE_IN: BargeInOptions = { calibrate: 5, sustain: 3, ratio: 3.5, minimum: 700, register: HER_REGISTER_HZ };

// frontend/src/lib/voiceTurn.ts:501-526, inside createBargeInDetector().feed (cwkPippa)
      if (level > Math.max(floor * options.ratio, options.minimum)) {
        const register = options.register;
        const hz = register && pitch ? pitch() : null;
        if (run.levels.length < HEARD_RUN_LIMIT) {
          run.levels.push(Math.round(level));
          run.pitches.push(hz === null ? null : Math.round(hz));
        }
        // Her voice neither counts nor breaks the run: Dad talking over
        // her leaks her into his chunks (2026-10-02, alternating 119-176 Hz
        // with 267-286 Hz), and a reset there held his cut-in back 2 s.
        if (register && hz !== null && hz >= register[0] && hz <= register[1]) {
          hers = true;
          return false;
        }
        loud += 1;
        if (register && hz !== null && hz < register[0]) low = true;
        // With her voice in the run, its unvoiced chunks could add up to a
        // cut-in on their own: it takes a chunk at Dad's pitch.
        if (loud < options.sustain || (hers && !low)) return false;
        tripped = true;
        return true;
      }
      endRun();
      floor = floor * 0.9 + level * 0.1;
      return false;
    },

from __future__ import annotations

import math
import random

RATE = 16000
CHUNK = 2048                     # 128 ms, the web's chunk
HER_REGISTER = (205.0, 360.0)    # Hz: her voice coming back from the speaker


def chunk_pitch(samples: list[float]) -> float | None:
    """Hann-windowed autocorrelation's strongest lag between 70 and 400 Hz,
    or None when it holds no more than 0.35 of the energy (unvoiced, noise)."""
    n = len(samples)
    shortest, longest = RATE // 400, RATE // 70
    if n <= longest:
        return None
    mean = sum(samples) / n
    x = [(s - mean) * (0.5 - 0.5 * math.cos(2 * math.pi * i / (n - 1))) for i, s in enumerate(samples)]
    energy = sum(v * v for v in x)
    if energy <= 0:
        return None
    best, best_lag = -math.inf, shortest
    for lag in range(shortest, longest):
        total = sum(x[i] * x[i + lag] for i in range(n - lag))
        if total > best:
            best, best_lag = total, lag
    return RATE / best_lag if best / energy > 0.35 else None


def rms(samples: list[float]) -> float:
    return math.sqrt(sum(s * s for s in samples) / len(samples))


class Detector:
    def __init__(self, register: tuple[float, float] | None,
                 calibrate: int = 5, sustain: int = 3, ratio: float = 3.5, minimum: float = 700.0) -> None:
        self.register, self.calibrate, self.sustain = register, calibrate, sustain
        self.ratio, self.minimum = ratio, minimum
        self.seen: list[float] = []
        self.floor: float | None = None
        self.end_run()

    def end_run(self) -> None:
        self.loud, self.low, self.hers = 0, False, False

    def feed(self, samples: list[float]) -> bool:
        level = rms(samples)
        if self.floor is None:
            self.seen.append(level)
            if len(self.seen) >= self.calibrate:
                self.floor = sorted(self.seen)[len(self.seen) // 2]
            return False
        if level > max(self.floor * self.ratio, self.minimum):
            hz = chunk_pitch(samples) if self.register else None
            if self.register and hz is not None and self.register[0] <= hz <= self.register[1]:
                self.hers = True          # her voice: neither counts nor breaks the run
                return False
            self.loud += 1
            if self.register and hz is not None and hz < self.register[0]:
                self.low = True           # a chunk at Dad's pitch
            return self.loud >= self.sustain and (not self.hers or self.low)
        self.end_run()
        self.floor = self.floor * 0.9 + level * 0.1
        return False


rng = random.Random(7)


def voice(hz: float, amplitude: float) -> list[float]:
    """A voiced chunk: a fundamental and two harmonics, a little noise."""
    return [amplitude * (math.sin(2 * math.pi * hz * t / RATE) + 0.5 * math.sin(4 * math.pi * hz * t / RATE)
                         + 0.25 * math.sin(6 * math.pi * hz * t / RATE)) + rng.gauss(0, amplitude * 0.05)
            for t in range(CHUNK)]


def noise(amplitude: float) -> list[float]:
    return [rng.gauss(0, amplitude) for _ in range(CHUNK)]


quiet = [noise(150) for _ in range(6)]                 # her echo and the room, cancelled
her = voice(270, 2500)                                  # she starts again after a pause
dad = voice(140, 2500)
hiss = noise(2500)                                      # loud, but no pitch at all

print("pitch of her leak:", round(chunk_pitch(her) or 0), "Hz | Dad:", round(chunk_pitch(dad) or 0),
      "Hz | hiss:", chunk_pitch(hiss))

runs = {
    "her voice leaks for half a second": [her] * 4,
    "Dad talks over her, her leak between": [dad, her, dad, her, dad],
    "her leak, then loud hiss with no pitch": [her, hiss, hiss, hiss],
    "Dad alone": [dad] * 3,
}
for name, run in runs.items():
    results = []
    for register in (None, HER_REGISTER):
        detector = Detector(register)
        cut = None
        for i, chunk in enumerate(quiet + run):
            if detector.feed(chunk):
                cut = i
                break
        results.append("no cut" if cut is None else f"cut at chunk {cut}")
    print(f"{name:40} loudness only: {results[0]:14} with her register: {results[1]}")

# Output:
# pitch of her leak: 271 Hz | Dad: 140 Hz | hiss: None
# her voice leaks for half a second        loudness only: cut at chunk 8 with her register: no cut
# Dad talks over her, her leak between     loudness only: cut at chunk 8 with her register: cut at chunk 10
# her leak, then loud hiss with no pitch   loudness only: cut at chunk 8 with her register: no cut
# Dad alone                                loudness only: cut at chunk 8 with her register: cut at chunk 8