duration_s: float, peak_amplitude: float = 0.8) -> List[int]:

"""生成 16-bit PCM 的白噪声爆发列（click train）。

total_samples = int(round(sample_rate * duration_s))

period_samples = max(1, int(round(sample_rate / repetition_hz)))

burst_samples = max(1, int(round(sample_rate * burst_ms / 1000.0)))

pcm: List[int] = [0] * total_samples

idx = 0

max_int16 = 32767

noise_scale = int(max_int16 * peak_amplitude)

while idx < total_samples:

end_idx = min(idx + burst_samples, total_samples)

for i in range(idx, end_idx):

# 简单白噪声：均匀分布 [-1, 1)

val = (2.0 * random.random() - 1.0) * noise_scale

pcm[i] = max(-32768, min(32767, int(val)))

idx += period_samples

with wave.open(filepath, 'wb') as wf:

wf.setnchannels(1)

wf.setsampwidth(2)

wf.setframerate(sample_rate)

# 小端有符号 16-bit

frames = struct.pack('<' + 'h' * len(samples), *samples)

view_ms: float = 100.0) -> None:

width = 1000

height = 400

padding = 30

mid_a = padding + (height // 2 - padding * 2) // 2

mid_b = height - padding - (height // 2 - padding * 2) // 2

view_samples = max(1, int(round(sample_rate * view_ms / 1000.0)))

def polyline_points(samples: List[int], mid_y: int) -> str:

xs = min(view_samples, len(samples))

points = []

for n in range(xs):

x = padding + n * (width - 2 * padding) / max(1, view_samples - 1)

y = mid_y - samples[n] / 32768.0 * (height // 2 - padding * 1.5)

points.append(f"{x:.2f},{y:.2f}")

return ' '.join(points)

pts_a = polyline_points(samples_a, mid_a)

pts_b = polyline_points(samples_b, mid_b)

svg = f"""

with open(svg_path, 'w', encoding='utf-8') as f:

"""读取 PCM16 单声道 WAV，检测爆发起点并估计重复频率。仅用标准库。

with wave.open(filepath, 'rb') as wf:

n_channels = wf.getnchannels()

sampwidth = wf.getsampwidth()

fs = wf.getframerate()

n_frames = wf.getnframes()

raw = wf.readframes(n_frames)

if n_channels != 1 or sampwidth != 2:

print(f"{filepath}: 当前实现仅支持单声道16-bit PCM。检测到 channels={n_channels}, sampwidth={sampwidth}")

return

samples = list(struct.unpack('<' + 'h' * n_frames, raw))

if fs != expected_fs:

print(f"⚠️ 采样率与预期不同: {fs} Hz (期望 {expected_fs} Hz)")

abs_vals = [abs(x) for x in samples]

max_abs = max(abs_vals) if abs_vals else 0

thr = max(200, int(max_abs * 0.10))

min_sep_samples = int(expected_fs * 0.005) # 5 ms 去抖

peaks: List[int] = []

last_peak = -min_sep_samples

prev_over = False

for i, v in enumerate(abs_vals):

over = v >= thr

if over and not prev_over and (i - last_peak) >= min_sep_samples:

peaks.append(i)

last_peak = i

prev_over = over

if len(peaks) < 2:

print(f"{filepath}: 未检测到足够的爆发以估计频率。")

return

intervals = [peaks[i + 1] - peaks[i] for i in range(len(peaks) - 1)]

mean_samp = sum(intervals) / len(intervals)

mean_ms = mean_samp / fs * 1000.0

# 标准差

var = sum((x - mean_samp) ** 2 for x in intervals) / len(intervals)

std_ms = (var ** 0.5) / fs * 1000.0

freq = fs / mean_samp if mean_samp > 0 else 0.0

print(f"{filepath}:")

print(f" 检测到爆发数: {len(peaks)}")

print(f" 平均间隔: {mean_ms:.2f} ms (Std: {std_ms:.2f} ms)")