From 563a6a8e1f484684ddcd4dc8a91ba3ded43450da Mon Sep 17 00:00:00 2001 From: Aqua Date: Sun, 8 Nov 2026 19:25:02 +0000 Subject: [PATCH] Stress carries duration, amplitude and f0 (source pitch_ratio surface); plosive release burst from contact release_flow; vowels open the contact Primary stress: duration 220/160, source flow x1.26 (+2 dB), f0 x1.06 (Sluijter & van Heuven 1996); secondary halfway (design value). The exporter's contact term adds white noise shaped by stored pressure and 4*o*(1-o) of the opening, gain from release_flow. Unheard. Co-Authored-By: Claude Sonnet 5.5 --- src/AquaSynth.Core/FaustExport.cs | 12 ++- src/AquaSynth.Core/IpaGestureExperiment.cs | 5 +- src/AquaSynth.Core/Model.cs | 3 +- src/AquaSynth.Core/PatchScript.cs | 30 +++++- src/AquaSynth.Core/ProbeTimelineReport.cs | 3 + src/AquaSynth.Core/WeksaPhones.cs | 26 +++-- .../StressAndReleaseRenderTests.cs | 98 +++++++++++++++++++ tests/AquaSynth.Dsl.Tests/WeksaPhonesTests.cs | 59 ++++++++--- 8 files changed, 204 insertions(+), 32 deletions(-) create mode 100644 tests/AquaSynth.Dsl.Tests/StressAndReleaseRenderTests.cs diff --git a/src/AquaSynth.Core/FaustExport.cs b/src/AquaSynth.Core/FaustExport.cs index 145eaf1..bd98e0b 100644 --- a/src/AquaSynth.Core/FaustExport.cs +++ b/src/AquaSynth.Core/FaustExport.cs @@ -714,6 +714,8 @@ public static partial class FaustEmitter var opening = parameters.Expression(OwnerField(owner, "opening"), port.Opening); var impedance = parameters.Expression(OwnerField(owner, "impedance"), port.Impedance); var flowScale = parameters.Expression(OwnerField(owner, "flow_scale"), port.FlowScale); + // f0 is the voice frequency times the source's ratio (the stress cue), smoothed over 10 ms so a step in the ratio is a glide. + var pitchRatio = $"({parameters.Expression(OwnerField(owner, "pitch_ratio"), port.PitchRatio)} : si.smooth(ba.tau2pole(0.01)))"; var load = $"{voiceName}_primitive_source_{safe}_load_pressure"; var voiced = $"{voiceName}_primitive_source_{safe}_voiced"; var flow = $"{voiceName}_primitive_source_{safe}_flow"; @@ -721,7 +723,7 @@ public static partial class FaustEmitter // Harmonic glottal source: a band-limited saw through a one-pole lowpass. Tilt 0 is the brightest source and 1 the // steepest rolloff; the cutoff sweeps five octaves, 6400 Hz down to 200 Hz, and sits below Nyquist. var cutoff = $"min(0.45 * ma.SR, 200.0 * pow(2.0, (1.0 - clip01({parameters.Expression(OwnerField(owner, "tilt"), port.Tilt)})) * 5.0))"; - source.AppendLine($" {voiced} = (os.sawtooth({frequency}) : fi.lowpass(1, {cutoff})) * clip01({opening}) * clip01(0.25 + {tension});"); + source.AppendLine($" {voiced} = (os.sawtooth(({frequency}) * {pitchRatio}) : fi.lowpass(1, {cutoff})) * clip01({opening}) * clip01(0.25 + {tension});"); source.AppendLine($" {flow} = {ProbeSignal(options, $"/debug/{voiceName}/source/{port.Name}/flow", $"({flowScale}) * (({voiced}) * ma.tanh((({pressure}) * (0.5 + {tension})) / max(0.05, {impedance})) + 0.08 * no.noise * {parameters.Expression(OwnerField(owner, "noise"), port.Noise)})", -2, 2)};"); keepAlive.Add(load); keepAlive.Add(voiced); @@ -744,13 +746,19 @@ public static partial class FaustEmitter var opening = $"clip01({parameters.Expression(OwnerField(owner, "opening"), contact.Opening)})"; var resistance = parameters.Expression(OwnerField(owner, "resistance"), contact.Resistance); var stored = parameters.Expression(OwnerField(owner, "stored_pressure"), contact.StoredPressure); + var releaseGain = parameters.Expression(OwnerField(owner, "release_flow"), contact.ReleaseFlow); var released = $"{voiceName}_primitive_contact_{safe}_released_flow"; var reservoir = $"{voiceName}_primitive_contact_{safe}_reservoir"; + var burst = $"{voiceName}_primitive_contact_{safe}_burst"; source.AppendLine($" {reservoir} = {ProbeSignal(options, $"/debug/{voiceName}/contact/{contact.Name}/reservoir", $"(({stored}) + (1.0 - {opening}) * {resistance})", 0, 2)};"); source.AppendLine($" {released} = {ProbeSignal(options, $"/debug/{voiceName}/contact/{contact.Name}/released_flow", $"({reservoir}) * {opening} * (1.0 - min(0.95, {resistance} * 0.5))", -2, 2)};"); + // Release burst: noise whose amplitude is the stored pressure through the opening area as it passes between shut and open + // (4 * o * (1 - o) peaks at half open and vanishes at both ends), so a shut or fully open contact is silent. + source.AppendLine($" {burst} = {ProbeSignal(options, $"/debug/{voiceName}/contact/{contact.Name}/burst", $"no.noise * ({releaseGain}) * ({stored}) * 4.0 * {opening} * (1.0 - {opening})", -2, 2)};"); keepAlive.Add(reservoir); + keepAlive.Add(burst); keepAlive.Add(released); - return released; + return $"({released} + {burst})"; } // Open fraction of a branch port: the ladder reads it as the velum area when the branch joins two paths of the network, diff --git a/src/AquaSynth.Core/IpaGestureExperiment.cs b/src/AquaSynth.Core/IpaGestureExperiment.cs index 91fe1b0..3e82dbc 100644 --- a/src/AquaSynth.Core/IpaGestureExperiment.cs +++ b/src/AquaSynth.Core/IpaGestureExperiment.cs @@ -8,7 +8,8 @@ public sealed record IpaGestureExperimentTarget( string Ipa, string Descriptor, float DurationSeconds = 0.18f, - string Notes = ""); + string Notes = "", + float PitchRatio = 1f); public sealed record IpaGestureExperimentVariant( string Id, @@ -225,7 +226,7 @@ public static class IpaGestureExperiment } private static string GestureLine(IpaGestureExperimentTarget target, float start, float duration, float intensity) => - $"phoneme_gesture name={SafeDslName(target.Id)} ipa={target.Ipa} {(target.Descriptor.Length == 0 ? "" : $"descriptor={target.Descriptor.Replace(' ', '_')} ")}start={Format(start)} dur={Format(duration)} intensity={Format(intensity)}"; + $"phoneme_gesture name={SafeDslName(target.Id)} ipa={target.Ipa} {(target.Descriptor.Length == 0 ? "" : $"descriptor={target.Descriptor.Replace(' ', '_')} ")}start={Format(start)} dur={Format(duration)} intensity={Format(intensity)}{(target.PitchRatio == 1f ? "" : $" pitch_ratio={Format(target.PitchRatio)}")}"; // One cell per sample at 48 kHz: 17.52 cm * 48000 / 350 m/s = 24.03 cells, a ladder 17.5 cm long (the mean of Story's vocal tract lengths). private const int TractSpeedMetersPerSecond = 350; diff --git a/src/AquaSynth.Core/Model.cs b/src/AquaSynth.Core/Model.cs index 7fda009..175bdfa 100644 --- a/src/AquaSynth.Core/Model.cs +++ b/src/AquaSynth.Core/Model.cs @@ -473,7 +473,8 @@ public sealed record SourcePort( float Noise = 0.08f, float Impedance = 0.35f, float FlowScale = 0.02f, - float Tilt = 0.5f); + float Tilt = 0.5f, + float PitchRatio = 1f); public sealed record ConstrictionContact( string Name, diff --git a/src/AquaSynth.Core/PatchScript.cs b/src/AquaSynth.Core/PatchScript.cs index 90b460c..699170d 100644 --- a/src/AquaSynth.Core/PatchScript.cs +++ b/src/AquaSynth.Core/PatchScript.cs @@ -938,7 +938,8 @@ public static class PatchScript GetBoundFloat(fields, line, 0.08f, $"/vocal/sources/{_sourcePorts.Count}/noise", "noise", "aspiration"), GetBoundFloat(fields, line, 0.35f, $"/vocal/sources/{_sourcePorts.Count}/impedance", "impedance", "load", "source_impedance"), GetBoundFloat(fields, line, 0.02f, $"/vocal/sources/{_sourcePorts.Count}/flow_scale", "flow_scale", "scale"), - GetBoundFloat(fields, line, 0.5f, $"/vocal/sources/{_sourcePorts.Count}/tilt", "tilt", "spectral_tilt")); + GetBoundFloat(fields, line, 0.5f, $"/vocal/sources/{_sourcePorts.Count}/tilt", "tilt", "spectral_tilt"), + GetBoundFloat(fields, line, 1f, $"/vocal/sources/{_sourcePorts.Count}/pitch_ratio", "pitch_ratio", "f0_ratio")); _sourcePorts.Add(port); _sourcePortsByName[name] = port; RegisterSourcePortSurfaces(_sourcePorts.Count - 1, port); @@ -1385,6 +1386,7 @@ public static class PatchScript RegisterNormalizedPrimitiveSurface(OwnerField(owner, "impedance"), port.Name, "impedance", port.Impedance, 0.05f, 2); RegisterNormalizedPrimitiveSurface(OwnerField(owner, "flow_scale"), port.Name, "flow_scale", port.FlowScale, 0, 0.2f); RegisterNormalizedPrimitiveSurface(OwnerField(owner, "tilt"), port.Name, "tilt", port.Tilt); + RegisterNormalizedPrimitiveSurface(OwnerField(owner, "pitch_ratio"), port.Name, "pitch_ratio", port.PitchRatio, 0.5f, 2f); } private void RegisterAreaFunctionSurfaces(int index, AreaFunction area) @@ -1502,7 +1504,7 @@ public static class PatchScript } } - private void EmitPhonemeGestureSplines(string name, string descriptor, float start, float duration, float intensity) + private void EmitPhonemeGestureSplines(string name, string descriptor, float start, float duration, float intensity, float pitchRatio = 1f) { var tokens = DescriptorTokens(descriptor); var voiced = tokens.Contains("voiced") || tokens.Contains("vowel") || tokens.Contains("nasal") || tokens.Contains("approximant"); @@ -1517,6 +1519,10 @@ public static class PatchScript AddAuthoredSpline($"{name}_source_pressure", "/vocal/sources/0/pressure", start, duration, (0, 0.4f), (0.2f, pressure), (1, pressure * 0.85f)); AddAuthoredSpline($"{name}_source_tension", "/vocal/sources/0/tension", start, duration, (0, voiced ? 0.55f : 0.18f), (1, voiced ? 0.62f : 0.20f)); AddAuthoredSpline($"{name}_source_opening", "/vocal/sources/0/opening", start, duration, (0, voiced ? 0.45f : 0.25f), (1, voiced ? 0.48f : 0.28f)); + // Intensity is an amplitude factor on the source's flow scale (the level lever: pressure saturates in the tanh), and the f0 ratio + // is held per gesture; both default to the source's own value. + HoldFractionOfDefault($"{name}_source_level", "/vocal/sources/0/flow_scale", start, duration, intensity); + HoldOnSurface($"{name}_source_pitch", "/vocal/sources/0/pitch_ratio", start, duration, pitchRatio); AddAuthoredSpline($"{name}_source_noise", "/vocal/sources/0/noise", start, duration, (0, tokens.Contains("fricative") ? 0.45f : 0.05f), (1, tokens.Contains("fricative") ? 0.55f : 0.05f)); if (tokens.Contains("vowel")) @@ -1556,6 +1562,9 @@ public static class PatchScript { AddAuthoredSpline($"{name}_contact", "/vocal/contacts/0/opening", start, duration, (0, 0.02f), (0.65f, 0.02f), (1, 0.9f)); AddAuthoredSpline($"{name}_stored_pressure", "/vocal/contacts/0/stored_pressure", start, duration, (0, 0.4f), (0.65f, 0.75f), (1, 0.05f)); + // The release burst is turbulence at the opening constriction: its gain is held for the plosive and the exporter shapes + // it by the stored pressure and the opening (see PrimitiveContactExpression). + HoldOnSurface($"{name}_release_flow", "/vocal/contacts/0/release_flow", start, duration, PlosiveBurstGain); AddAuthoredSpline($"{name}_velum", "/vocal/branches/0/opening", start, duration, (0, VelumClosed), (1, VelumClosed)); } else if (tokens.Contains("fricative")) @@ -1590,6 +1599,16 @@ public static class PatchScript // area as well counted the rounding twice and left /u/ 30 dB under /i/. AddAuthoredSpline($"{name}_lip_radiation", "/vocal/radiation/0/aperture", start, duration, (0, 1), (1, 1)); AddAuthoredSpline($"{name}_velum", "/vocal/branches/0/opening", start, duration, (0, VelumClosed), (1, VelumClosed)); + // The contact is fully open for a vowel; a contact left half open by the previous stop would keep making release noise. + AddAuthoredSpline($"{name}_contact", "/vocal/contacts/0/opening", start, duration, (0, 1), (1, 1)); + } + + // Holds a surface at its default value times a factor (clamped to the surface range). + private void HoldFractionOfDefault(string name, string surfacePath, float start, float duration, float factor) + { + if (!_controlSurfacesByPath.TryGetValue(surfacePath, out var surface)) return; + var normalized = Math.Clamp(surface.DefaultNormalized * factor, 0, 1); + AddAuthoredSpline(name, surfacePath, start, duration, (0, normalized), (1, normalized)); } // Holds a surface at a value in its own unit (cm, section index); splines carry the surface's normalized range. @@ -1634,6 +1653,10 @@ public static class PatchScript // leave a 0.008 cm^2 leak that shows in the oral formants. private const float VelumClosed = 0f; + // Gain of the plosive release burst (contact release_flow, surface range 0..2). A DESIGN VALUE set by measurement against the + // following vowel; no published burst level was retrieved. + private const float PlosiveBurstGain = 0.06f; + // Distance from the lip plane to the alveolar ridge in cm. A DESIGN VALUE; no source for the distance was retrieved. 2.555 cm puts the // closure on the centre of ladder cell 20 of 24 of the scaffold tract (17.52 cm at 48 kHz and 350 m/s: (20.5 / 24) * 17.52 = 14.965 cm // from the glottis), the cell grid being what a narrow constriction (scaffold constriction_width .03, e-fold 0.63 cm) can close; it is @@ -2655,13 +2678,14 @@ public static class PatchScript var start = GetFloat(fields, line, 0, "start", "time", "at"); var duration = Math.Max(0.001f, GetFloat(fields, line, 0.12f, "dur", "duration", "length")); var intensity = Math.Clamp(GetFloat(fields, line, 1, "intensity", "gain", "strength"), 0, 2); + var pitchRatio = Math.Clamp(GetFloat(fields, line, 1, "pitch_ratio", "f0_ratio"), 0.5f, 2f); var descriptor = GestureDescriptor(ipa, fields); var name = TryGetAny(fields, ["name", "n"], out var nameText) ? nameText : $"ipa_{SafeName(ipa)}_{_phonemeGestures.Count}"; _phonemeGestures.Add(new PhonemeGesture(name, ipa, descriptor, start, duration, intensity)); - EmitPhonemeGestureSplines(name, descriptor, start, duration, intensity); + EmitPhonemeGestureSplines(name, descriptor, start, duration, intensity, pitchRatio); } private void AddControlCurve(IReadOnlyDictionary fields, int line) diff --git a/src/AquaSynth.Core/ProbeTimelineReport.cs b/src/AquaSynth.Core/ProbeTimelineReport.cs index 2af5959..42bf89f 100644 --- a/src/AquaSynth.Core/ProbeTimelineReport.cs +++ b/src/AquaSynth.Core/ProbeTimelineReport.cs @@ -80,6 +80,9 @@ public static class ProbeTimelineReport Add(samples, block, $"contact:{contact.Name}", "resistance", resistance); Add(samples, block, $"contact:{contact.Name}", "reservoir", reservoir); Add(samples, block, $"contact:{contact.Name}", "released_flow", reservoir * opening * (1 - Math.Min(0.95f, resistance * 0.5f))); + var releaseGain = SurfaceValue(surfacesByField, splinesBySurface, $"{owner}/release_flow", contact.ReleaseFlow, timeSeconds); + // The exporter's burst is white noise of this amplitude (noise itself is not mirrored). + Add(samples, block, $"contact:{contact.Name}", "burst_amplitude", releaseGain * stored * 4 * opening * (1 - opening)); } foreach (var branchName in network.Branches) diff --git a/src/AquaSynth.Core/WeksaPhones.cs b/src/AquaSynth.Core/WeksaPhones.cs index 9939c79..92da8e3 100644 --- a/src/AquaSynth.Core/WeksaPhones.cs +++ b/src/AquaSynth.Core/WeksaPhones.cs @@ -71,19 +71,28 @@ public static class WeksaPhonesReader /// /// A Weksa phones line as a word the tract can render. Every phone must be in the DSL's IPA table /// (); a phone outside it is listed in and the plan -/// carries no targets, so nothing is approximated. Duration is the vowel/consonant length AquaSynth owns; stress moves -/// only the gesture intensity, the one thing the word script uses stress for. +/// carries no targets, so nothing is approximated. Base durations are the vowel/consonant lengths AquaSynth owns; stress +/// carries its three acoustic cues (): the marked phone is longer, louder and higher in f0. /// public sealed record WeksaWordPlan(IReadOnlyList<(IpaGestureExperimentTarget Target, float Intensity)> Phones, IReadOnlyList Unsupported) { public const float VowelSeconds = 0.18f, ConsonantSeconds = 0.095f; public bool Renderable => Unsupported.Count == 0; - public static float StressIntensity(WeksaStress stress) => stress switch + /// Duration factor, amplitude factor on the source flow and f0 ratio of a stressed phone against an unstressed one. + public readonly record struct StressCue(float Duration, float Amplitude, float PitchRatio); + + /// + /// Primary stress: duration 220/160 = 1.375 (stressed against unstressed syllable in initial-stress pairs, Sluijter and van + /// Heuven 1996), amplitude 2 dB = 1.26 (the 1-3 dB overall-intensity difference they report), f0 +6 percent (their unaccented + /// f0 difference). Secondary stress is placed halfway, in dB and in percent: a DESIGN VALUE, no secondary-stress measurement was + /// retrieved. Unheard. + /// + public static StressCue CueFor(WeksaStress stress) => stress switch { - WeksaStress.Primary => 1.2f, - WeksaStress.Secondary => 1.1f, - _ => 1f + WeksaStress.Primary => new(220f / 160f, 1.26f, 1.06f), + WeksaStress.Secondary => new(1.19f, 1.12f, 1.03f), + _ => new(1f, 1f, 1f) }; public static WeksaWordPlan From(WeksaPhones word, string label) @@ -93,8 +102,9 @@ public sealed record WeksaWordPlan(IReadOnlyList<(IpaGestureExperimentTarget Tar var targets = word.Phones.Select((p, i) => { PatchScript.TryIpaDescriptor(p.Ipa, out var descriptor); - var seconds = descriptor.EndsWith("_vowel", StringComparison.Ordinal) ? VowelSeconds : ConsonantSeconds; - return (new IpaGestureExperimentTarget($"{label}_{i}_{p.Ipa}", p.Ipa, "", seconds), StressIntensity(p.Stress)); + var cue = CueFor(p.Stress); + var seconds = (descriptor.EndsWith("_vowel", StringComparison.Ordinal) ? VowelSeconds : ConsonantSeconds) * cue.Duration; + return (new IpaGestureExperimentTarget($"{label}_{i}_{p.Ipa}", p.Ipa, "", seconds, PitchRatio: cue.PitchRatio), cue.Amplitude); }).ToArray(); return new WeksaWordPlan(targets, []); } diff --git a/tests/AquaSynth.Dsl.Tests/StressAndReleaseRenderTests.cs b/tests/AquaSynth.Dsl.Tests/StressAndReleaseRenderTests.cs new file mode 100644 index 0000000..84ff78a --- /dev/null +++ b/tests/AquaSynth.Dsl.Tests/StressAndReleaseRenderTests.cs @@ -0,0 +1,98 @@ +using AquaSynth.Dsl; +using AquaSynth.Faust; +using Xunit.Abstractions; + +namespace AquaSynth.Dsl.Tests; + +// Renders the two cues the tract gained in this pass through the native Faust path: the source's f0 ratio (the stress pitch cue) and +// the plosive release burst. Each asserts a measured signal, not the emitted text. +[Collection("NativeFaust")] +public sealed class StressAndReleaseRenderTests(ITestOutputHelper output) +{ + private const int Rate = 48000; + + private static float[]? Render(string script, float seconds, Func? edit = null) + { + var parsed = PatchScript.Parse(script); + var source = FaustEmitter.Emit(edit is null ? parsed : edit(parsed), new FaustExportOptions("stress_release", SampleRate: Rate)).Source; + using var compiler = new AquaSynthPatchCompiler(new AquaSynthNativeOptions(SampleRate: Rate)); + if (!compiler.TryCompileSource(new AquaSynthCompileIdentity("stress_release", "stress_release", ""), source, seconds, out var patch, out var error)) + { + if (error?.Contains("Faust toolchain not found", StringComparison.OrdinalIgnoreCase) == true || + error?.Contains("Faust DLL not found", StringComparison.OrdinalIgnoreCase) == true) + { + return null; + } + + Assert.Fail($"compile failed: {error}"); + } + + using (patch) return patch!.Render(seconds); + } + + private static double Rms(float[] x, double from, double to) + { + var a = (int)(from * Rate); + var b = Math.Min(x.Length, (int)(to * Rate)); + double sum = 0; + for (var i = a; i < b; i++) sum += (double)x[i] * x[i]; + return Math.Sqrt(sum / Math.Max(1, b - a)); + } + + private static double Peak(float[] x, double from, double to) => + x.Skip((int)(from * Rate)).Take((int)((to - from) * Rate)).Max(Math.Abs); + + // f0 by the highest autocorrelation peak between 60 and 400 Hz. + private static double F0(float[] x, double from, double to) + { + var seg = x.Skip((int)(from * Rate)).Take((int)((to - from) * Rate)).Select(v => (double)v).ToArray(); + double best = 0; var bestLag = 0; + for (var lag = Rate / 400; lag <= Rate / 60; lag++) + { + double c = 0; + for (var i = 0; i + lag < seg.Length; i++) c += seg[i] * seg[i + lag]; + if (c > best) { best = c; bestLag = lag; } + } + + return (double)Rate / bestLag; + } + + [Fact] + public void SourcePitchRatioScalesTheRenderedF0() + { + var f0 = (float ratio) => + { + var script = IpaGestureExperiment.BuildWordScript([(new IpaGestureExperimentTarget("w_0_a", "a", "", 0.5f, PitchRatio: ratio), 1f)], 110); + var x = Render(script, 0.6f); + return x is null ? double.NaN : F0(x, 0.2, 0.5); + }; + var unity = f0(1f); + var up = f0(1.5f); + output.WriteLine($"f0 at ratio 1: {unity:F1}, ratio 1.5: {up:F1}"); + if (double.IsNaN(unity)) return; + Assert.InRange(unity, 108, 112); + Assert.InRange(up, 163, 167); + } + + [Fact] + public void PlosiveReleaseBurstIsAboveTheClosureAndBelowTheFollowingVowel() + { + var script = IpaGestureExperiment.BuildWordScript( + [(new IpaGestureExperimentTarget("w_0_b", "b", "", 0.095f), 1f), (new IpaGestureExperimentTarget("w_1_a", "a", "", 0.18f), 1f)], 140); + var withBurst = Render(script, 0.4f); + var withoutBurst = Render(script, 0.4f, p => p with { ControlSplines = p.ControlSplines.Where(s => !s.SurfacePath.EndsWith("/release_flow", StringComparison.Ordinal)).ToArray() }); + if (withBurst is null || withoutBurst is null) return; + // Everything but the burst's noise is deterministic and shared, so the difference of the two renders is the burst alone. + var burst = withBurst.Zip(withoutBurst, (x, y) => x - y).ToArray(); + const double releaseFrom = 0.095 * 0.65, vowelFrom = 0.095; + var vowelPeak = Peak(withBurst, vowelFrom + 0.06, vowelFrom + 0.18); + var burstPeak = Peak(burst, releaseFrom, vowelFrom + 0.01); + var burstBeforeRelease = Peak(burst, 0, releaseFrom - 0.005); + var burstAfter = Peak(burst, vowelFrom + 0.04, 0.4); + output.WriteLine($"burst peak {burstPeak:F4} in the release, {burstBeforeRelease:F5} in the closure, {burstAfter:F5} in the vowel; vowel peak {vowelPeak:F4}"); + Assert.True(burstPeak > 0.004, "the burst is a transient of audible size in the release window"); + Assert.True(burstBeforeRelease < burstPeak / 20, "the closure is silent: no burst before the release"); + Assert.True(burstAfter < burstPeak / 5, "the burst is over once the vowel is open"); + Assert.True(burstPeak < vowelPeak / 2, "the burst stays well under the following vowel's peak (the b level fix)"); + } +} diff --git a/tests/AquaSynth.Dsl.Tests/WeksaPhonesTests.cs b/tests/AquaSynth.Dsl.Tests/WeksaPhonesTests.cs index 40991f3..cb5a3e7 100644 --- a/tests/AquaSynth.Dsl.Tests/WeksaPhonesTests.cs +++ b/tests/AquaSynth.Dsl.Tests/WeksaPhonesTests.cs @@ -74,7 +74,7 @@ public sealed class WeksaPhonesTests var word = WeksaPhonesReader.Parse(Line($"[{Ph("b", "none")},{Ph("ɪ", "primary")},{Ph("n", "none")},{Ph("b", "none")},{Ph("ʊ", "none")}]")); var plan = WeksaWordPlan.From(word, "x"); Assert.True(plan.Renderable); - Assert.Equal([WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.VowelSeconds, WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.VowelSeconds], + Assert.Equal([WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.VowelSeconds * WeksaWordPlan.CueFor(WeksaStress.Primary).Duration, WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.ConsonantSeconds, WeksaWordPlan.VowelSeconds], plan.Phones.Select(p => p.Target.DurationSeconds)); var patch = PatchScript.Parse(IpaGestureExperiment.BuildWordScript(plan.Phones.ToArray(), 140)); var ih = patch.ControlSplines.Where(s => s.Name.StartsWith("x_1_ɪ_vowel_", StringComparison.Ordinal)).ToDictionary(s => s.SurfacePath, s => s.Points[0].Value); @@ -85,22 +85,49 @@ public sealed class WeksaPhonesTests Assert.Equal(0f, oo["/vocal/areas/0/area/vowel_u"]); } - [Fact] - public void StressMovesOnlyTheIntensityOfTheMarkedPhone() - { - string Script(WeksaStress onI) => IpaGestureExperiment.BuildWordScript( - WeksaWordPlan.From(new WeksaPhones("en-US", "ˈnibu", - [new("n", WeksaStress.None), new("i", onI), new("b", WeksaStress.None), new("u", WeksaStress.None)]), "w").Phones.ToArray()); + private static WeksaWordPlan Plan(WeksaStress onI) => WeksaWordPlan.From(new WeksaPhones("en-US", "ˈnibu", + [new("n", WeksaStress.None), new("i", onI), new("b", WeksaStress.None), new("u", WeksaStress.None)]), "w"); - var none = Script(WeksaStress.None).Split('\n'); - var primary = Script(WeksaStress.Primary).Split('\n'); - Assert.Equal(none.Length, primary.Length); - var differing = Enumerable.Range(0, none.Length).Where(i => none[i] != primary[i]).ToArray(); - Assert.Single(differing); - Assert.Contains("ipa=i ", primary[differing[0]]); - var strip = (string l) => Regex.Replace(l, @"intensity=\S+", ""); - Assert.Equal(strip(none[differing[0]]), strip(primary[differing[0]])); - Assert.Contains("intensity=1.2", primary[differing[0]]); + [Fact] + public void StressIsLongerLouderAndHigherOnTheMarkedPhoneOnly() + { + var none = Plan(WeksaStress.None).Phones; + var primary = Plan(WeksaStress.Primary).Phones; + var secondary = Plan(WeksaStress.Secondary).Phones; + foreach (var k in new[] { 0, 2, 3 }) + { + Assert.Equal(none[k].Target, primary[k].Target); + Assert.Equal(none[k].Intensity, primary[k].Intensity); + } + + Assert.Equal(WeksaWordPlan.VowelSeconds, none[1].Target.DurationSeconds); + Assert.Equal(1f, none[1].Target.PitchRatio); + Assert.Equal(1f, none[1].Intensity); + Assert.Equal(WeksaWordPlan.VowelSeconds * 220f / 160f, primary[1].Target.DurationSeconds, 5); + Assert.Equal(1.06f, primary[1].Target.PitchRatio); + Assert.Equal(1.26f, primary[1].Intensity); + // Secondary sits strictly between unstressed and primary on every cue. + Assert.InRange(secondary[1].Target.DurationSeconds, none[1].Target.DurationSeconds + 1e-4f, primary[1].Target.DurationSeconds - 1e-4f); + Assert.InRange(secondary[1].Target.PitchRatio, 1.001f, 1.059f); + Assert.InRange(secondary[1].Intensity, 1.001f, 1.259f); + } + + [Fact] + public void StressReachesTheScriptAsDurationF0RatioAndSourceLevelAndShiftsLaterPhones() + { + var patch = (WeksaStress s) => PatchScript.Parse(IpaGestureExperiment.BuildWordScript(Plan(s).Phones.ToArray(), 140)); + var none = patch(WeksaStress.None); + var primary = patch(WeksaStress.Primary); + float First(SynthPatch p, string prefix, string surface) => + p.ControlSplines.Single(sp => sp.Name.StartsWith(prefix, StringComparison.Ordinal) && sp.SurfacePath == surface).Points[0].Value; + + // pitch_ratio surface range 0.5..2: normalized (1.06 - .5) / 1.5; unstressed holds 1 -> (1 - .5) / 1.5. + Assert.Equal((1.06f - .5f) / 1.5f, First(primary, "w_1_i_source_pitch", "/vocal/sources/0/pitch_ratio"), 4); + Assert.Equal((1f - .5f) / 1.5f, First(none, "w_1_i_source_pitch", "/vocal/sources/0/pitch_ratio"), 4); + Assert.Equal(First(none, "w_1_i_source_level", "/vocal/sources/0/flow_scale") * 1.26f, First(primary, "w_1_i_source_level", "/vocal/sources/0/flow_scale"), 4); + // The b after the stressed vowel starts later by the vowel's extra length. + float Start(SynthPatch p) => p.PhonemeGestures.Single(g => g.Ipa == "b").StartSeconds; + Assert.Equal(WeksaWordPlan.VowelSeconds * (220f / 160f - 1f), Start(primary) - Start(none), 4); } [Fact]