Replace bioacoustic triplets with speaker words
This commit is contained in:
parent
1f385002a7
commit
4af29802c8
11 changed files with 212 additions and 271 deletions
|
|
@ -69,10 +69,10 @@ one attractive correlation peak.
|
|||
|
||||
The active calibration path is deliberately receiver-cheap in both `chirp-only`
|
||||
and `hybrid`. `MimirBioacousticTimeline` is the live runtime witness: it emits
|
||||
low-gain log-frequency motifs made from short formant-rich syllables, rhythm
|
||||
offsets, and a de Bruijn triplet grammar. Acquisition is an energy proposal pass
|
||||
plus bounded motif matching; timeline placement is the same code-valid triplet
|
||||
trellis, and a constrained local waveform correlation around the decoded delay
|
||||
low-gain log-frequency words made from short formant-rich syllables, rhythm
|
||||
offsets, and speaker-specific variants. Acquisition is an energy proposal pass
|
||||
plus bounded motif matching; timeline placement comes from direct word identity,
|
||||
and a constrained local waveform correlation around the decoded delay
|
||||
provides the final fractional offset. The decoder keeps per-band response
|
||||
evidence for each detected motif so the same stream can calibrate timing and the
|
||||
speaker/room/mic transfer function.
|
||||
|
|
@ -95,8 +95,8 @@ sequence order so the timeline remains unique without pretending dead bands
|
|||
still carry code.
|
||||
The synthetic invariant is
|
||||
`dotnet run --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --bioacoustic-self-test`;
|
||||
it renders the bioacoustic timeline, decodes motif anchors, and requires
|
||||
code-valid triplets plus a stable source clock. The standalone invariant is
|
||||
it renders the bioacoustic timeline, decodes direct word anchors, and requires a
|
||||
stable source clock. The standalone invariant is
|
||||
`--standalone-bioacoustic-self-test --sample-rate 48000 --delay-samples 1269.5`;
|
||||
it proves that a delayed receiver can recover canonical source time from the
|
||||
known codebook and schedule alone. `chirp-only` emits this witness continuously;
|
||||
|
|
@ -156,7 +156,7 @@ current studio-monitor-to-Scarlett-mic acoustic path was already weak by
|
|||
unproven until a measured transducer/mic path earns it.
|
||||
|
||||
The active bioacoustic timing proof now runs in memory through the same runtime
|
||||
analyzer path. `--bioacoustic-self-test` proves code-valid motif anchors,
|
||||
analyzer path. `--bioacoustic-self-test` proves direct word anchors,
|
||||
`--standalone-bioacoustic-self-test --sample-rate 48000 --delay-samples 1269.5`
|
||||
proves a receiver can recover canonical source time from delayed audio alone,
|
||||
and `--chirp-only-sync-self-test --sample-rate 48000` recovers a 317.375-sample
|
||||
|
|
@ -169,10 +169,10 @@ through `asio-ch3`.
|
|||
The full probe runtime config now enables sample-bearing blocks for every local
|
||||
audio source. `MimirBioacousticTimeline` owns the emitted calibration stream and
|
||||
the motif-matching shape used to analyze it. The default timeline is a
|
||||
deterministic order-3 de Bruijn symbol sequence over 16 log-frequency motifs.
|
||||
Any three consecutive correctly detected motifs identify the event index inside
|
||||
the current operating horizon, so a receiver can place its audio window on the
|
||||
canonical timeline without being handed Mimir's runtime clock. Mimir queues
|
||||
deterministic set of self-identifying log-frequency words with separate left and
|
||||
right speaker variants. Any correctly detected word identifies the event index
|
||||
inside the current operating horizon, so a receiver can place its audio window
|
||||
on the canonical timeline without being handed Mimir's runtime clock. Mimir queues
|
||||
half-second PCM segments ahead of the audio cursor. Each motif is a short phrase
|
||||
of formant-rich syllables with log-frequency contour and rhythm offsets, so the
|
||||
code is carried by both spectral shape and timing.
|
||||
|
|
@ -180,10 +180,10 @@ code is carried by both spectral shape and timing.
|
|||
The intended decoder is a compact constrained motif transform, not a generic
|
||||
time-frequency explorer and not an outlier filter around bad guesses. Mimir owns
|
||||
the emitter, so the receiver projects each mic stream against the known motif
|
||||
dictionary, produces transform frames with multiple symbol candidates, and
|
||||
scores candidate triplets through the de Bruijn map. A triplet only becomes a
|
||||
canonical timeline anchor when its symbol likelihoods, measured inter-motif
|
||||
gaps, and neighboring anchors agree on one local sample clock. A decoded anchor
|
||||
dictionary, produces transform frames with multiple word candidates, and maps
|
||||
the best coherent word identities directly to canonical events. A word becomes a
|
||||
canonical timeline anchor when its motif likelihood and neighboring anchors
|
||||
agree on one local sample clock. A decoded anchor
|
||||
means observed sample offset `S` corresponds to emitted event time `T`. A stream
|
||||
of anchors fits the source clock directly:
|
||||
|
||||
|
|
@ -193,8 +193,8 @@ observed_sample = source_offset + canonical_seconds * effective_sample_rate
|
|||
|
||||
Delay and sampling-rate offset are derived by comparing the loopback clock fit
|
||||
to each mic clock fit over common canonical time. The state tracker is not
|
||||
allowed to launder invalid codewords into plausible timing. If a stream cannot
|
||||
produce at least three matched canonical anchors, it has not decoded timing for
|
||||
allowed to launder invalid words into plausible timing. If a stream cannot
|
||||
produce at least one matched canonical anchor, it has not decoded timing for
|
||||
that window. Reports carry rounded integer delay, fractional delay, and the
|
||||
count/confidence of timeline-symbol anchors used to derive the report.
|
||||
|
||||
|
|
@ -233,7 +233,7 @@ flowchart TD
|
|||
E --> G["matched chirplet traces"]
|
||||
F --> G
|
||||
G --> H["symbol likelihood events"]
|
||||
H --> L["triplet timeline anchors"]
|
||||
H --> L["timeline anchors"]
|
||||
L --> M["per-source clock fit"]
|
||||
M --> N["delay + SRO"]
|
||||
G --> I["per-source calibration profile"]
|
||||
|
|
|
|||
|
|
@ -7,13 +7,14 @@ That shape proved the math, but it is the wrong animal for a room.
|
|||
|
||||
Mimir now treats active acoustic sync as a low-gain bioacoustic language: short
|
||||
birdsong-like motifs whose identity survives through contour, log-frequency
|
||||
position, spectral envelope, rhythm, and phrase order. The receiver should not
|
||||
position, spectral envelope, rhythm, and speaker-specific timbre. The receiver should not
|
||||
ask only "which bin fired?" It should ask:
|
||||
|
||||
```text
|
||||
which motif contour did I hear?
|
||||
where does this motif phrase sit in the canonical grammar?
|
||||
what delay and clock fit make the whole phrase coherent?
|
||||
which self-identifying word did that contour encode?
|
||||
which speaker vocabulary emitted it?
|
||||
what delay and clock fit make the heard words coherent?
|
||||
what did this room/mic path do to the spectrum?
|
||||
```
|
||||
|
||||
|
|
@ -21,14 +22,18 @@ what did this room/mic path do to the spectrum?
|
|||
|
||||
`MimirBioacousticTimeline` is the current active runtime watermark.
|
||||
|
||||
- 16 log-spaced motif symbols.
|
||||
- Each motif contains three short syllables.
|
||||
- 128 self-identifying word positions, each with a left-speaker and
|
||||
right-speaker variant.
|
||||
- Each word contains four short syllables.
|
||||
- Each syllable carries a log-frequency glide plus formant-like partials.
|
||||
- Motif rhythm varies by symbol group.
|
||||
- The timeline is an order-3 de Bruijn grammar, so any three correctly decoded
|
||||
consecutive motifs identify canonical event position.
|
||||
- The decoder emits motif candidates, code-valid triplet anchors, a source
|
||||
clock fit, and per-band response evidence.
|
||||
- Motif rhythm, contour, syllable duration, root, and speaker tint vary by word.
|
||||
- No de Bruijn grammar is used in the active bioacoustic path. A word identifies
|
||||
its canonical event directly inside the current operating horizon.
|
||||
- The decoder emits motif candidates, direct word anchors, a source clock fit,
|
||||
and per-band response evidence.
|
||||
- Runtime emission sends the left vocabulary to the left speaker and the right
|
||||
vocabulary to the right speaker, so microphones can learn each side of the
|
||||
room separately.
|
||||
- The runtime active sync evidence kind is `bioacoustic`.
|
||||
|
||||
The old `MimirChirpBinTimeline` remains as a calibration/reference artifact
|
||||
|
|
@ -44,7 +49,7 @@ watermark target.
|
|||
- deterministic phrase schedule;
|
||||
- PCM rendering for active emission;
|
||||
- streaming motif scoring;
|
||||
- de Bruijn triplet anchor decoding;
|
||||
- direct word anchor decoding;
|
||||
- source clock fitting;
|
||||
- response-band evidence.
|
||||
|
||||
|
|
@ -65,8 +70,9 @@ Birdsong survives ugly channels because the information is redundant:
|
|||
- contour survives when absolute pitch shifts;
|
||||
- rhythm survives when frequency response is bad;
|
||||
- formant envelope survives when one band dies;
|
||||
- phrase grammar survives when individual syllables are weak;
|
||||
- repeated local structure gives the receiver more than one way to recover time.
|
||||
- speaker-specific variants expose room asymmetry;
|
||||
- repeated local structure gives the receiver more than one way to recover time
|
||||
and response.
|
||||
|
||||
That is the physical path Mimir needs. A phone mic, camera mic, Scarlett input,
|
||||
or network receiver should be able to recognize canonical time from a damaged
|
||||
|
|
@ -84,8 +90,8 @@ dotnet run --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --chirp
|
|||
|
||||
Expected state:
|
||||
|
||||
- `--bioacoustic-self-test` recovers code-valid motif anchors across the
|
||||
canonical phrase.
|
||||
- `--bioacoustic-self-test` recovers direct word anchors across the canonical
|
||||
phrase.
|
||||
- `--standalone-bioacoustic-self-test` recovers delayed canonical source time
|
||||
from codebook/schedule state alone.
|
||||
- `--chirp-only-sync-self-test` reports `evidence=bioacoustic` and recovers
|
||||
|
|
@ -106,7 +112,7 @@ cut is a true streaming log-mel receiver:
|
|||
audio window
|
||||
-> log-mel / constant-Q evidence surface
|
||||
-> motif/formant/contour candidates
|
||||
-> phrase grammar decode
|
||||
-> direct word identity decode
|
||||
-> global delay and clock hypothesis
|
||||
-> path response model
|
||||
```
|
||||
|
|
|
|||
|
|
@ -36,8 +36,8 @@ mode:
|
|||
|
||||
Active bioacoustic decode uses known codebook/schedule state. It proposes motif
|
||||
times from local energy, classifies log-frequency/formant symbols by bounded
|
||||
matched motif scoring, constrains candidates through de Bruijn code-valid
|
||||
triplets, fits a clock, and records band response evidence for calibration.
|
||||
matched motif scoring, maps self-identifying words directly to canonical events,
|
||||
fits a clock, and records band response evidence for calibration.
|
||||
|
||||
## Invariants
|
||||
|
||||
|
|
@ -810,10 +810,11 @@ Owns:
|
|||
|
||||
Core state:
|
||||
|
||||
- Sixteen log-spaced motif symbols.
|
||||
- Three short formant-rich syllables per motif.
|
||||
- A de Bruijn order-three schedule, so any valid motif triplet identifies one
|
||||
canonical timeline location.
|
||||
- 128 self-identifying word positions.
|
||||
- Left-speaker and right-speaker variants for each word.
|
||||
- Four short formant-rich syllables per word.
|
||||
- Direct word identity, so a valid word identifies one canonical timeline
|
||||
location in the current operating horizon.
|
||||
- Cached kernels by sample rate.
|
||||
|
||||
Blocks:
|
||||
|
|
@ -821,7 +822,7 @@ Blocks:
|
|||
- Motif/syllable records: `MimirBioacousticMotifDefinition` and
|
||||
`MimirBioacousticSyllable`.
|
||||
- `RenderSegmentMonoFloat`: renders one low-gain timeline segment.
|
||||
- `DecodeStreamWindow`: detects motif frames, decodes code-valid triplet
|
||||
- `DecodeStreamWindow`: detects motif frames, decodes direct word
|
||||
anchors, fits source clock, refines standalone source offset, and emits the
|
||||
shared `MimirChirpletStreamDecode` shape.
|
||||
- `EventForIndex` / `EventsOverlapping`: expose canonical schedule metadata.
|
||||
|
|
@ -829,14 +830,14 @@ Blocks:
|
|||
suppresses nearby duplicate motif hits.
|
||||
- `ClassifyAt`: scores a local candidate against the motif bank.
|
||||
- `ScoreMotif`: matched motif scoring with per-band response evidence.
|
||||
- `DecodeAnchors`: maps detected motif triplets back to canonical event indexes.
|
||||
- `DecodeAnchors`: maps detected words back to canonical event indexes.
|
||||
- `FitClock` and `RefineSourceOffset`: recover source timeline position and
|
||||
sub-frame offset from known codebook/schedule state.
|
||||
|
||||
Invariant:
|
||||
|
||||
- A receiver with only the codebook, schedule, and its local audio buffer can
|
||||
recover canonical time once it hears a code-valid motif triplet.
|
||||
recover canonical time once it hears a valid motif word.
|
||||
|
||||
## Stage 9: Chirp-Bin Reference Timeline
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ a named invariant that the native runtime cannot protect yet.
|
|||
hub, and prints the actual rolling buffers. Use `--require-samples` when an
|
||||
empty declared sensor buffer should fail the run. Use `--bioacoustic-self-test`
|
||||
to render the active motif timeline into memory and verify that the decoder
|
||||
recovers code-valid anchors. Use `--standalone-bioacoustic-self-test` to
|
||||
recovers direct word anchors. Use `--standalone-bioacoustic-self-test` to
|
||||
verify that a receiver with only the codebook/schedule can recover canonical
|
||||
source offset from delayed audio.
|
||||
- `native/probes/wasapi_audio_cadence` captures WASAPI mic or render-loopback
|
||||
|
|
@ -65,10 +65,11 @@ a named invariant that the native runtime cannot protect yet.
|
|||
capture raw interleaved Float32 ASIO input with `--record-f32-interleaved`.
|
||||
- `MimirBioacousticTimeline` owns the active runtime watermark described in
|
||||
[[bioacoustic-timeline-watermark|Bioacoustic Timeline Watermark]]. It renders
|
||||
a low-gain birdsong-like phrase language: 16 log-spaced motif symbols, three
|
||||
formant-rich syllables per motif, rhythm variation, and an order-3 de Bruijn
|
||||
grammar so any three correctly decoded consecutive motifs identify canonical
|
||||
timeline position. Runtime active sync now reports `evidence=bioacoustic`.
|
||||
a low-gain birdsong-like word language: 128 self-identifying word positions,
|
||||
left-speaker and right-speaker variants, four formant-rich syllables per word,
|
||||
rhythm variation, and direct word identity so a correctly decoded word
|
||||
identifies canonical timeline position. Runtime active sync now reports
|
||||
`evidence=bioacoustic`.
|
||||
- `MimirChirpletTimeline` owns the older structured chirplet calibration stream,
|
||||
PCM segment rendering, matched timing trace, and per-band response kernels.
|
||||
It remains a reference/diagnostic path.
|
||||
|
|
@ -81,8 +82,8 @@ a named invariant that the native runtime cannot protect yet.
|
|||
and clock coherence, and fits a per-source sample clock from those anchors.
|
||||
- `MimirAudioSynchronizationAnalyzer` ports the first live sync measurement:
|
||||
sample-bearing audio blocks are resampled into the Scarlett loopback timeline.
|
||||
The analyzer derives delay only from matched decoded triplet timeline anchors.
|
||||
A source without at least three matched anchors has no timing report for that
|
||||
The analyzer derives delay only from matched decoded timeline anchors.
|
||||
A source without at least one matched anchor has no timing report for that
|
||||
window. It accepts Float32, Int16, Int24, and Int32 PCM windows so ASIO/native
|
||||
capture can feed true interface formats without a pre-conversion shim.
|
||||
- `MimirAudioSynchronizationStateTracker` owns the first smoothed per-source
|
||||
|
|
@ -183,13 +184,14 @@ a named invariant that the native runtime cannot protect yet.
|
|||
2. Feed those drivers into `MimirVideoCaptureDriverSource` and prove sustained
|
||||
frame cadence in the rolling buffers.
|
||||
3. Use bioacoustic motif response profiles from real microphones to tune
|
||||
contour, formant, band, gain, and rhythm weighting without weakening the
|
||||
standalone codebook/schedule receiver invariant. Keep chirp-bin calibration
|
||||
artifacts as reference data, not the runtime target.
|
||||
contour, formant, band, gain, rhythm weighting, and left/right speaker
|
||||
separation without weakening the standalone word-identity receiver invariant.
|
||||
Keep chirp-bin calibration artifacts as reference data, not the runtime
|
||||
target.
|
||||
4. Add the synchronization actuator: drive a variable-rate resampler and
|
||||
fractional delay line per non-reference stream from the smoothed
|
||||
`MimirAudioSynchronizationState`. First, prove the bioacoustic motif decoder
|
||||
through real loopback and microphone paths so every correctly heard triplet
|
||||
through real loopback and microphone paths so every correctly heard word
|
||||
becomes a deterministic timeline anchor before the actuator moves samples.
|
||||
5. Prove the bioacoustic hybrid fallback through real loopback and microphones
|
||||
with probe durations long enough to keep loopback and mic windows live.
|
||||
|
|
|
|||
|
|
@ -100,20 +100,21 @@ is the current timing authority when active calibration is playing, but Scarlett
|
|||
production capture belongs on ASIO rather than WASAPI shared mode.
|
||||
`MimirBioacousticTimeline` owns the active runtime watermark described in
|
||||
[[docs/bioacoustic-timeline-watermark|Bioacoustic Timeline Watermark]]: a
|
||||
low-gain birdsong-like phrase language with 16 log-spaced motif symbols, three
|
||||
formant-rich syllables per motif, rhythm variation, and an order-3 de Bruijn
|
||||
grammar. Any three consecutive correctly decoded motifs identify the event
|
||||
index inside the current operating horizon. Mimir continuously queues that
|
||||
timeline through Fensalir audio and decodes timing as `bioacoustic` evidence.
|
||||
low-gain birdsong-like word language with 128 self-identifying word positions,
|
||||
left-speaker and right-speaker variants, four formant-rich syllables per word,
|
||||
rhythm variation, and direct word identity. Any correctly decoded word identifies
|
||||
the event index inside the current operating horizon. Mimir queues the left
|
||||
vocabulary to the left speaker and the right vocabulary to the right speaker
|
||||
through Fensalir audio, then decodes timing as `bioacoustic` evidence.
|
||||
`MimirAudioSynchronizationSettings.Mode` chooses whether active calibration is
|
||||
allowed: `chirp-only` emits the active bioacoustic witness, `passive` stays silent
|
||||
and uses program-audio phase correlation, and `hybrid` uses passive evidence by
|
||||
default while emitting active pilot chunks only when passive confidence is weak.
|
||||
Active decoding does not inherit the passive two-second analysis floor: passive
|
||||
still needs a longer program-audio window, while the bioacoustic witness can
|
||||
decode once at least a code-valid motif triplet is present. The bioacoustic
|
||||
detector now uses generous motif proposals, matched motif scoring, triplet
|
||||
grammar decoding, source clock fitting, and fractional waveform refinement.
|
||||
decode once at least one self-identifying word is present. The bioacoustic
|
||||
detector now uses bounded motif proposals, matched motif scoring, direct word
|
||||
anchors, source clock fitting, and fractional waveform refinement.
|
||||
Pairwise sync compares matched anchors first, then only accepts independent
|
||||
clock-fit offsets inside the live latency horizon so period aliases do not
|
||||
become absurd reports. The old chirp-bin detector remains as a
|
||||
|
|
@ -124,7 +125,7 @@ timing residuals, delay hypotheses, phase summaries, and an adaptive codebook
|
|||
plan. The analyzer keeps raw profiles even when no timing report is accepted,
|
||||
so physical mic failures can still guide bioacoustic motif weighting. Reports/states
|
||||
expose `delayUs` next to fractional sample delay.
|
||||
`Mimir.BufferSmoke --bioacoustic-self-test` proves code-valid motif anchors.
|
||||
`Mimir.BufferSmoke --bioacoustic-self-test` proves direct word anchors.
|
||||
`--standalone-bioacoustic-self-test --sample-rate 48000 --delay-samples 1269.5`
|
||||
proves a receiver with only codebook/schedule state can recover delayed source
|
||||
time to below printed microsecond precision. `--chirp-only-sync-self-test
|
||||
|
|
|
|||
|
|
@ -72,9 +72,9 @@ Get-Content .\state\evidence.jsonl -Tail 8
|
|||
Kiyo and second PS3 Eye were absent, so six-camera viability is not proven.
|
||||
- Current active sync smoke uses Scarlett speaker loopback as timing
|
||||
authority. `MimirBioacousticTimeline` now owns the active runtime watermark:
|
||||
low-gain birdsong-like motifs with log-spaced roots, formant-rich syllables,
|
||||
rhythm variation, and an order-3 de Bruijn phrase grammar. Any three
|
||||
consecutive correctly decoded motifs identify the event index inside the
|
||||
low-gain birdsong-like words with log-spaced roots, left/right speaker
|
||||
variants, four formant-rich syllables, rhythm variation, and direct word
|
||||
identity. Any correctly decoded word identifies the event index inside the
|
||||
current operating horizon. Runtime active sync reports
|
||||
`evidence=bioacoustic`; [[docs/bioacoustic-timeline-watermark|Bioacoustic
|
||||
Timeline Watermark]] is the current map. Sync reports now include
|
||||
|
|
@ -90,14 +90,14 @@ Get-Content .\state\evidence.jsonl -Tail 8
|
|||
when passive confidence is weak. The active bioacoustic path has its own
|
||||
short-window analyzer floor instead of inheriting the passive two-second gate.
|
||||
It uses energy/onset proposals, dense fallback probes, bounded motif matching,
|
||||
de Bruijn triplet anchoring, clock fit, and constrained local waveform
|
||||
direct word anchoring, clock fit, and constrained local waveform
|
||||
correlation for final fractional delay. It also supports standalone source
|
||||
offset recovery from schedule/codebook state, which is the Raven/phone shape.
|
||||
Each classified motif carries per-band response evidence. The older
|
||||
`MimirChirpBinCalibrationModel` remains the controlled chirp-bin
|
||||
response/confusion/delay reference surface; use it to inform bioacoustic motif
|
||||
weighting, not as the runtime sound.
|
||||
`Mimir.BufferSmoke --bioacoustic-self-test` proves code-valid motif anchors.
|
||||
`Mimir.BufferSmoke --bioacoustic-self-test` proves direct word anchors.
|
||||
`--standalone-bioacoustic-self-test --sample-rate 48000 --delay-samples
|
||||
1269.5` recovers delayed canonical time below printed microsecond precision
|
||||
without loopback. `--chirp-only-sync-self-test --sample-rate 48000` recovers a
|
||||
|
|
|
|||
|
|
@ -362,7 +362,7 @@ static int RunBioacousticSelfTest(int sampleRate)
|
|||
$"error={anchor.SampleOffset - expected:0.000} confidence={anchor.Confidence:0.000}");
|
||||
}
|
||||
|
||||
if (decode.ClockFit == null || decode.Anchors.Count < 12 || meanAbsoluteError > 12.0)
|
||||
if (decode.ClockFit == null || decode.Anchors.Count < 10 || meanAbsoluteError > 12.0)
|
||||
{
|
||||
Console.Error.WriteLine("bioacoustic self-test failed: log-motif decoder did not recover stable timeline anchors");
|
||||
return 1;
|
||||
|
|
@ -521,7 +521,7 @@ static int RunActiveSyncSelfTest(int sampleRate, MimirAudioSyncMode mode)
|
|||
}
|
||||
|
||||
return string.Equals(report.EvidenceKind, "bioacoustic", StringComparison.Ordinal) &&
|
||||
report.TimelineMatchedEvents >= 3 &&
|
||||
report.TimelineMatchedEvents >= 1 &&
|
||||
report.Confidence > 0.70 &&
|
||||
error * 1_000_000.0 / report.SampleRate < 1.0
|
||||
? 0
|
||||
|
|
@ -629,7 +629,7 @@ static int RenderBioacousticFloat32(string outputPath, int sampleRate, double se
|
|||
}
|
||||
|
||||
File.WriteAllBytes(outputPath, bytes);
|
||||
Console.WriteLine($"bioacoustic-render-f32 path={outputPath} sampleRate={sampleRate} seconds={seconds:0.000} samples={samples.Count} symbols={MimirBioacousticTimeline.SymbolCount} order={MimirBioacousticTimeline.TimelineOrder}");
|
||||
Console.WriteLine($"bioacoustic-render-f32 path={outputPath} sampleRate={sampleRate} seconds={seconds:0.000} samples={samples.Count} words={MimirBioacousticTimeline.WordCount} speakers={MimirBioacousticTimeline.SpeakerCount}");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -189,17 +189,31 @@ public sealed class MimirRuntime : IAquariumRuntime
|
|||
|
||||
var segmentCount = audioSyncSettings.Mode == MimirAudioSyncMode.Hybrid ? 1 : CalibrationBatchSegments;
|
||||
var outputGain = audioSyncSettings.Mode == MimirAudioSyncMode.Hybrid ? watermarkGain : calibrationGain;
|
||||
var batch = RenderCalibrationBatchPcm16Base64(
|
||||
var leftBatch = RenderCalibrationBatchPcm16Base64(
|
||||
calibrationSegmentIndex,
|
||||
segmentCount,
|
||||
MimirBioacousticSpeaker.Left,
|
||||
out var peak);
|
||||
var rightBatch = RenderCalibrationBatchPcm16Base64(
|
||||
calibrationSegmentIndex,
|
||||
segmentCount,
|
||||
MimirBioacousticSpeaker.Right,
|
||||
out var rightPeak);
|
||||
peak = Math.Max(peak, rightPeak);
|
||||
audio.EnqueuePcm16Base64(
|
||||
batch,
|
||||
leftBatch,
|
||||
MimirBioacousticTimeline.SampleRate,
|
||||
channels: 1,
|
||||
gain: outputGain);
|
||||
gain: outputGain,
|
||||
pan: -1.0f);
|
||||
audio.EnqueuePcm16Base64(
|
||||
rightBatch,
|
||||
MimirBioacousticTimeline.SampleRate,
|
||||
channels: 1,
|
||||
gain: outputGain,
|
||||
pan: 1.0f);
|
||||
Console.WriteLine(
|
||||
$"mimir-bioacoustic-batch mode={DescribeAudioSyncMode()} firstSegment={calibrationSegmentIndex} segments={segmentCount} seconds={segmentCount * MimirBioacousticTimeline.SegmentSeconds:0.00} peak={peak:0.000000} gain={outputGain:0.###} base64Bytes={batch.Length}");
|
||||
$"mimir-bioacoustic-batch mode={DescribeAudioSyncMode()} firstSegment={calibrationSegmentIndex} segments={segmentCount} seconds={segmentCount * MimirBioacousticTimeline.SegmentSeconds:0.00} peak={peak:0.000000} gain={outputGain:0.###} leftBase64Bytes={leftBatch.Length} rightBase64Bytes={rightBatch.Length}");
|
||||
if (audioSyncSettings.Mode == MimirAudioSyncMode.Hybrid)
|
||||
{
|
||||
lastHybridWatermarkSegment = (long)calibrationSegmentIndex;
|
||||
|
|
@ -234,6 +248,7 @@ public sealed class MimirRuntime : IAquariumRuntime
|
|||
private static string RenderCalibrationBatchPcm16Base64(
|
||||
ulong firstSegment,
|
||||
int segmentCount,
|
||||
MimirBioacousticSpeaker speaker,
|
||||
out float peak)
|
||||
{
|
||||
var samplesPerSegment = (int)Math.Round(MimirBioacousticTimeline.SegmentSeconds * MimirBioacousticTimeline.SampleRate);
|
||||
|
|
@ -244,7 +259,8 @@ public sealed class MimirRuntime : IAquariumRuntime
|
|||
{
|
||||
var samples = MimirBioacousticTimeline.Default.RenderSegmentMonoFloat(
|
||||
firstSegment + (ulong)segment,
|
||||
MimirBioacousticTimeline.SampleRate);
|
||||
MimirBioacousticTimeline.SampleRate,
|
||||
speaker);
|
||||
for (var index = 0; index < samples.Length; index++)
|
||||
{
|
||||
peak = Math.Max(peak, Math.Abs(samples[index]));
|
||||
|
|
|
|||
|
|
@ -201,8 +201,8 @@ public sealed class MimirAudioSynchronizationAnalyzer
|
|||
BestFrameEnergy(candidateDecode),
|
||||
deterministicFit.MatchedEvents,
|
||||
deterministicFit.Confidence,
|
||||
deterministicFit.MatchedEvents >= 3 ? "report" : "insufficient-anchors"));
|
||||
if (deterministicFit.MatchedEvents < 3)
|
||||
deterministicFit.MatchedEvents >= 1 ? "report" : "insufficient-anchors"));
|
||||
if (deterministicFit.MatchedEvents < 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
|
@ -305,7 +305,7 @@ public sealed class MimirAudioSynchronizationAnalyzer
|
|||
Math.Sqrt(referenceAnchor.Confidence * candidateAnchor.Confidence)));
|
||||
}
|
||||
|
||||
if (matched.Count >= 3)
|
||||
if (matched.Count >= 1)
|
||||
{
|
||||
var totalWeight = matched.Sum(pair => Math.Max(1.0e-6, pair.Weight));
|
||||
var delay = matched.Sum(pair => pair.Delay * Math.Max(1.0e-6, pair.Weight)) / totalWeight;
|
||||
|
|
|
|||
|
|
@ -21,33 +21,32 @@ internal sealed record BioacousticKernel(
|
|||
internal sealed record BioacousticKernelSet(
|
||||
BioacousticKernel[] Symbols);
|
||||
|
||||
internal sealed record BioacousticTimelinePlan(
|
||||
int[] Symbols,
|
||||
int Order,
|
||||
int[] TimelineSymbols,
|
||||
Dictionary<string, int> CodeToIndex);
|
||||
public enum MimirBioacousticSpeaker
|
||||
{
|
||||
Left = 0,
|
||||
Right = 1,
|
||||
}
|
||||
|
||||
public sealed class MimirBioacousticTimeline
|
||||
{
|
||||
public const int SampleRate = 48_000;
|
||||
public const double SegmentSeconds = 0.5;
|
||||
public const int SymbolCount = 16;
|
||||
public const int TimelineOrder = 3;
|
||||
public const int WordCount = 128;
|
||||
public const int SpeakerCount = 2;
|
||||
public const int SymbolCount = WordCount * SpeakerCount;
|
||||
public const int TimelineOrder = 1;
|
||||
|
||||
private const double FirstEventSeconds = 0.08;
|
||||
private const double EventSpacingSeconds = 0.16;
|
||||
private const double MotifDurationSeconds = 0.118;
|
||||
private const double SyllableSeconds = 0.034;
|
||||
private const double LowestRootHz = 3_200.0;
|
||||
private const double HighestRootHz = 8_800.0;
|
||||
private const double Gain = 0.038;
|
||||
private const double LowestRootHz = 2_600.0;
|
||||
private const double HighestRootHz = 9_600.0;
|
||||
private const double Gain = 0.030;
|
||||
private const int MaxSymbolCandidatesPerFrame = 3;
|
||||
private const double ProposalBudgetMultiplier = 7.0;
|
||||
private const double ProposalBudgetMultiplier = 4.0;
|
||||
|
||||
private static readonly int[] TimelineSymbols = RotateToDistinctOpening(BuildDeBruijn(SymbolCount, TimelineOrder));
|
||||
private static readonly MimirBioacousticMotifDefinition[] Motifs = BuildMotifs();
|
||||
private static readonly ConcurrentDictionary<int, BioacousticKernelSet> KernelSets = new();
|
||||
private static readonly ConcurrentDictionary<string, BioacousticTimelinePlan> TimelinePlans = new();
|
||||
|
||||
public static MimirBioacousticTimeline Default { get; } = new();
|
||||
|
||||
|
|
@ -68,6 +67,19 @@ public sealed class MimirBioacousticTimeline
|
|||
return samples;
|
||||
}
|
||||
|
||||
public float[] RenderSegmentMonoFloat(ulong segmentIndex, int sampleRate, MimirBioacousticSpeaker speaker)
|
||||
{
|
||||
var segmentStartSeconds = segmentIndex * SegmentSeconds;
|
||||
var samples = new float[(int)Math.Round(SegmentSeconds * sampleRate)];
|
||||
foreach (var timelineEvent in EventsOverlapping(segmentStartSeconds, SegmentSeconds)
|
||||
.Where(timelineEvent => SpeakerForSymbol(timelineEvent.SymbolId) == speaker))
|
||||
{
|
||||
AddMotif(samples, sampleRate, timelineEvent, segmentStartSeconds, Gain);
|
||||
}
|
||||
|
||||
return samples;
|
||||
}
|
||||
|
||||
public MimirChirpletStreamDecode DecodeStreamWindow(ReadOnlySpan<float> samples, int sampleRate)
|
||||
{
|
||||
if (samples.Length == 0)
|
||||
|
|
@ -315,91 +327,37 @@ public sealed class MimirBioacousticTimeline
|
|||
IReadOnlyList<MimirChirpletTransformFrame> frames,
|
||||
int sampleRate)
|
||||
{
|
||||
var plan = GetTimelinePlan();
|
||||
if (frames.Count < plan.Order)
|
||||
if (frames.Count == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
var candidates = new List<MimirChirpletTimelineAnchor>();
|
||||
for (var index = 0; index <= frames.Count - plan.Order; index++)
|
||||
foreach (var frame in frames)
|
||||
{
|
||||
var window = frames.Skip(index).Take(plan.Order).ToArray();
|
||||
var consecutive = true;
|
||||
for (var gap = 0; gap < window.Length - 1; gap++)
|
||||
foreach (var candidate in frame.Candidates)
|
||||
{
|
||||
if (!IsConsecutive(window[gap], window[gap + 1], sampleRate))
|
||||
{
|
||||
consecutive = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!consecutive)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach (var candidatePath in CandidateSymbolPaths(window))
|
||||
{
|
||||
var code = CodeKey(candidatePath.Select(candidate => candidate.SymbolId));
|
||||
if (!plan.CodeToIndex.TryGetValue(code, out var eventIndex))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var firstEvent = Default.EventForIndex((ulong)eventIndex);
|
||||
var gapError = 0.0;
|
||||
for (var gap = 0; gap < candidatePath.Count - 1; gap++)
|
||||
{
|
||||
var measuredGap = (candidatePath[gap + 1].SampleOffset - candidatePath[gap].SampleOffset) / sampleRate;
|
||||
gapError += Math.Abs(measuredGap - EventSpacingSeconds);
|
||||
}
|
||||
|
||||
var gapConfidence = 1.0 / (1.0 + gapError / 0.006);
|
||||
var energyConfidence = Math.Clamp(candidatePath.Average(candidate => candidate.Energy), 0.0, 1.0);
|
||||
var eventIndex = EventIndexForSymbol(candidate.SymbolId);
|
||||
var expectedEvent = Default.EventForIndex((ulong)eventIndex);
|
||||
var speakerConfidence = SpeakerForSymbol(candidate.SymbolId) == SpeakerForEvent((ulong)eventIndex)
|
||||
? 1.0
|
||||
: 0.25;
|
||||
var energyConfidence = Math.Clamp(candidate.Energy, 0.0, 1.0);
|
||||
candidates.Add(new MimirChirpletTimelineAnchor(
|
||||
(ulong)eventIndex,
|
||||
firstEvent.StartSeconds,
|
||||
candidatePath[0].SampleOffset,
|
||||
gapConfidence * 0.35 + energyConfidence * 0.65,
|
||||
candidatePath
|
||||
.Select(candidate => new MimirChirpletSymbolObservation(
|
||||
candidate.SymbolId,
|
||||
candidate.SampleOffset,
|
||||
candidate.Energy))
|
||||
.ToArray()));
|
||||
expectedEvent.StartSeconds,
|
||||
candidate.SampleOffset,
|
||||
energyConfidence * speakerConfidence,
|
||||
[new MimirChirpletSymbolObservation(
|
||||
candidate.SymbolId,
|
||||
candidate.SampleOffset,
|
||||
candidate.Energy)]));
|
||||
}
|
||||
}
|
||||
|
||||
return SelectCoherentAnchorPath(candidates, sampleRate);
|
||||
}
|
||||
|
||||
private static IEnumerable<IReadOnlyList<MimirChirpletSymbolCandidate>> CandidateSymbolPaths(
|
||||
IReadOnlyList<MimirChirpletTransformFrame> frames)
|
||||
{
|
||||
var path = new MimirChirpletSymbolCandidate[frames.Count];
|
||||
IEnumerable<IReadOnlyList<MimirChirpletSymbolCandidate>> Recurse(int index)
|
||||
{
|
||||
if (index == frames.Count)
|
||||
{
|
||||
yield return path.ToArray();
|
||||
yield break;
|
||||
}
|
||||
|
||||
foreach (var candidate in frames[index].Candidates)
|
||||
{
|
||||
path[index] = candidate;
|
||||
foreach (var result in Recurse(index + 1))
|
||||
{
|
||||
yield return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Recurse(0);
|
||||
}
|
||||
|
||||
private static IReadOnlyList<MimirChirpletTimelineAnchor> SelectCoherentAnchorPath(
|
||||
IReadOnlyList<MimirChirpletTimelineAnchor> candidates,
|
||||
int sampleRate)
|
||||
|
|
@ -628,15 +586,6 @@ public sealed class MimirBioacousticTimeline
|
|||
return kept.OrderBy(frame => frame.SampleOffset).ToArray();
|
||||
}
|
||||
|
||||
private static bool IsConsecutive(
|
||||
MimirChirpletTransformFrame first,
|
||||
MimirChirpletTransformFrame second,
|
||||
int sampleRate)
|
||||
{
|
||||
var seconds = (second.SampleOffset - first.SampleOffset) / sampleRate;
|
||||
return seconds >= EventSpacingSeconds * 0.62 && seconds <= EventSpacingSeconds * 1.38;
|
||||
}
|
||||
|
||||
private static void AddMotif(
|
||||
float[] samples,
|
||||
int sampleRate,
|
||||
|
|
@ -720,37 +669,55 @@ public sealed class MimirBioacousticTimeline
|
|||
{
|
||||
var contourBank = new[]
|
||||
{
|
||||
new[] { 1.00, 1.24, 1.10, 1.42, 1.16, 1.04 },
|
||||
new[] { 1.00, 0.86, 1.18, 1.08, 0.94, 1.30 },
|
||||
new[] { 1.00, 1.36, 1.58, 1.28, 1.08, 1.22 },
|
||||
new[] { 1.00, 1.10, 0.82, 1.02, 1.34, 1.56 },
|
||||
new[] { 1.00, 1.22, 1.09, 1.48, 1.18, 1.03, 1.34, 1.18 },
|
||||
new[] { 1.00, 0.84, 1.20, 1.07, 0.93, 1.32, 1.12, 0.98 },
|
||||
new[] { 1.00, 1.38, 1.60, 1.26, 1.07, 1.24, 1.45, 1.16 },
|
||||
new[] { 1.00, 1.11, 0.81, 1.02, 1.36, 1.57, 1.20, 1.42 },
|
||||
new[] { 1.00, 0.92, 1.42, 1.18, 1.53, 1.10, 0.96, 1.28 },
|
||||
new[] { 1.00, 1.30, 0.88, 1.16, 1.05, 1.51, 1.39, 1.08 },
|
||||
new[] { 1.00, 1.56, 1.24, 0.91, 1.15, 1.37, 0.98, 1.22 },
|
||||
new[] { 1.00, 0.78, 0.96, 1.44, 1.62, 1.25, 1.08, 1.33 },
|
||||
};
|
||||
var rhythmOffsets = new[]
|
||||
{
|
||||
new[] { 0.000, 0.039, 0.079 },
|
||||
new[] { 0.000, 0.032, 0.083 },
|
||||
new[] { 0.000, 0.046, 0.073 },
|
||||
new[] { 0.000, 0.035, 0.069 },
|
||||
new[] { 0.000, 0.024, 0.057, 0.091 },
|
||||
new[] { 0.000, 0.031, 0.049, 0.087 },
|
||||
new[] { 0.000, 0.019, 0.061, 0.082 },
|
||||
new[] { 0.000, 0.036, 0.064, 0.096 },
|
||||
new[] { 0.000, 0.027, 0.071, 0.094 },
|
||||
new[] { 0.000, 0.041, 0.059, 0.089 },
|
||||
new[] { 0.000, 0.022, 0.052, 0.103 },
|
||||
new[] { 0.000, 0.034, 0.076, 0.098 },
|
||||
};
|
||||
var motifs = new MimirBioacousticMotifDefinition[SymbolCount];
|
||||
var logLowest = Math.Log(LowestRootHz);
|
||||
var logStep = Math.Log(HighestRootHz / LowestRootHz) / (SymbolCount - 1);
|
||||
var logStep = Math.Log(HighestRootHz / LowestRootHz) / (WordCount - 1);
|
||||
for (var symbol = 0; symbol < motifs.Length; symbol++)
|
||||
{
|
||||
var root = Math.Exp(logLowest + symbol * logStep);
|
||||
var contour = contourBank[symbol % contourBank.Length];
|
||||
var rhythm = rhythmOffsets[(symbol / contourBank.Length) % rhythmOffsets.Length];
|
||||
var syllables = new MimirBioacousticSyllable[3];
|
||||
var word = EventIndexForSymbol(symbol);
|
||||
var speaker = SpeakerForSymbol(symbol);
|
||||
var speakerShift = speaker == MimirBioacousticSpeaker.Left ? 0.94 : 1.08;
|
||||
var root = Math.Exp(logLowest + word * logStep) * speakerShift;
|
||||
var contour = contourBank[HashToRange(word, speaker, 0, contourBank.Length)];
|
||||
var rhythm = rhythmOffsets[HashToRange(word, speaker, 1, rhythmOffsets.Length)];
|
||||
var syllables = new MimirBioacousticSyllable[4];
|
||||
for (var syllable = 0; syllable < syllables.Length; syllable++)
|
||||
{
|
||||
var start = root * contour[syllable * 2];
|
||||
var end = root * contour[syllable * 2 + 1];
|
||||
var duration = 0.020 + 0.004 * HashToRange(word, speaker, 10 + syllable, 4);
|
||||
var weight = 1.0 - syllable * 0.08;
|
||||
if (speaker == MimirBioacousticSpeaker.Right)
|
||||
{
|
||||
weight *= syllable % 2 == 0 ? 0.90 : 1.08;
|
||||
}
|
||||
|
||||
syllables[syllable] = new MimirBioacousticSyllable(
|
||||
rhythm[syllable],
|
||||
SyllableSeconds,
|
||||
Math.Clamp(start, 2_700.0, 13_500.0),
|
||||
Math.Clamp(end, 2_700.0, 13_500.0),
|
||||
1.0 - syllable * 0.10);
|
||||
duration,
|
||||
Math.Clamp(start, 2_300.0, 14_600.0),
|
||||
Math.Clamp(end, 2_300.0, 14_600.0),
|
||||
weight);
|
||||
}
|
||||
|
||||
motifs[symbol] = new MimirBioacousticMotifDefinition(symbol, syllables);
|
||||
|
|
@ -761,84 +728,30 @@ public sealed class MimirBioacousticTimeline
|
|||
|
||||
private static int SymbolForEvent(ulong eventIndex)
|
||||
{
|
||||
var plan = GetTimelinePlan();
|
||||
return plan.TimelineSymbols[(int)(eventIndex % (ulong)plan.TimelineSymbols.Length)];
|
||||
var word = (int)(eventIndex % WordCount);
|
||||
return word * SpeakerCount + (int)SpeakerForEvent(eventIndex);
|
||||
}
|
||||
|
||||
private static int EventIndexForSymbol(int symbolId) =>
|
||||
Math.Clamp(symbolId / SpeakerCount, 0, WordCount - 1);
|
||||
|
||||
private static MimirBioacousticSpeaker SpeakerForEvent(ulong eventIndex) =>
|
||||
(eventIndex & 1UL) == 0UL ? MimirBioacousticSpeaker.Left : MimirBioacousticSpeaker.Right;
|
||||
|
||||
private static MimirBioacousticSpeaker SpeakerForSymbol(int symbolId) =>
|
||||
(symbolId & 1) == 0 ? MimirBioacousticSpeaker.Left : MimirBioacousticSpeaker.Right;
|
||||
|
||||
private static double EventStartSeconds(ulong eventIndex) =>
|
||||
FirstEventSeconds + eventIndex * EventSpacingSeconds;
|
||||
|
||||
private static BioacousticTimelinePlan GetTimelinePlan() =>
|
||||
TimelinePlans.GetOrAdd("default", _ => new BioacousticTimelinePlan(
|
||||
Enumerable.Range(0, SymbolCount).ToArray(),
|
||||
TimelineOrder,
|
||||
TimelineSymbols,
|
||||
BuildCodeIndex(TimelineSymbols, TimelineOrder)));
|
||||
|
||||
private static int[] BuildDeBruijn(int alphabetSize, int order)
|
||||
private static int HashToRange(int word, MimirBioacousticSpeaker speaker, int salt, int range)
|
||||
{
|
||||
var a = new int[alphabetSize * order];
|
||||
var sequence = new List<int>((int)Math.Pow(alphabetSize, order));
|
||||
|
||||
void Db(int t, int p)
|
||||
{
|
||||
if (t > order)
|
||||
{
|
||||
if (order % p == 0)
|
||||
{
|
||||
for (var index = 1; index <= p; index++)
|
||||
{
|
||||
sequence.Add(a[index]);
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
a[t] = a[t - p];
|
||||
Db(t + 1, p);
|
||||
for (var j = a[t - p] + 1; j < alphabetSize; j++)
|
||||
{
|
||||
a[t] = j;
|
||||
Db(t + 1, t);
|
||||
}
|
||||
}
|
||||
|
||||
Db(1, 1);
|
||||
return sequence.ToArray();
|
||||
var value = (uint)(word * 0x45d9f3b + ((int)speaker + 1) * 0x119de1f3 + salt * 0x27d4eb2d);
|
||||
value ^= value >> 16;
|
||||
value *= 0x7feb352d;
|
||||
value ^= value >> 15;
|
||||
value *= 0x846ca68b;
|
||||
value ^= value >> 16;
|
||||
return (int)(value % (uint)Math.Max(1, range));
|
||||
}
|
||||
|
||||
private static int[] RotateToDistinctOpening(int[] sequence)
|
||||
{
|
||||
for (var index = 0; index < sequence.Length; index++)
|
||||
{
|
||||
var first = sequence[index];
|
||||
var second = sequence[(index + 1) % sequence.Length];
|
||||
var third = sequence[(index + 2) % sequence.Length];
|
||||
if (first != second && first != third && second != third)
|
||||
{
|
||||
return sequence.Skip(index).Concat(sequence.Take(index)).ToArray();
|
||||
}
|
||||
}
|
||||
|
||||
return sequence;
|
||||
}
|
||||
|
||||
private static Dictionary<string, int> BuildCodeIndex(IReadOnlyList<int> symbols, int order)
|
||||
{
|
||||
var map = new Dictionary<string, int>(symbols.Count, StringComparer.Ordinal);
|
||||
for (var index = 0; index < symbols.Count; index++)
|
||||
{
|
||||
var code = CodeKey(Enumerable.Range(0, order).Select(offset => symbols[(index + offset) % symbols.Count]));
|
||||
if (!map.ContainsKey(code))
|
||||
{
|
||||
map[code] = index;
|
||||
}
|
||||
}
|
||||
|
||||
return map;
|
||||
}
|
||||
|
||||
private static string CodeKey(IEnumerable<int> symbols) =>
|
||||
string.Join(",", symbols);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,10 +65,12 @@ accepted_design:
|
|||
runtime rolling buffers; it does not carry pixels/audio payloads or own the
|
||||
final local-device hot path.
|
||||
- `MimirBioacousticTimeline` is the active runtime watermark. It renders a
|
||||
low-gain birdsong-like phrase language with 16 log-spaced motif symbols,
|
||||
three formant-rich syllables per motif, rhythm variation, and an order-3
|
||||
de Bruijn grammar. `MimirAudioSynchronizationAnalyzer` now reports active
|
||||
timing as `evidence=bioacoustic`; the old chirp-bin path remains a
|
||||
low-gain birdsong-like word language with 128 self-identifying word
|
||||
positions, left-speaker and right-speaker variants, four formant-rich
|
||||
syllables per word, rhythm variation, and direct word identity instead of a
|
||||
de Bruijn grammar. `MimirRuntime` emits separate panned vocabularies per
|
||||
speaker. `MimirAudioSynchronizationAnalyzer` reports active timing as
|
||||
`evidence=bioacoustic`; the old chirp-bin path remains a
|
||||
calibration/reference artifact with ASIO tooling.
|
||||
- The diagnostic audio path can optionally carry base64 float sample payloads
|
||||
for sync smoke tests. `MimirChirpletTimeline` owns the older structured
|
||||
|
|
@ -109,10 +111,10 @@ accepted_design:
|
|||
contradictory evidence and carry zero confidence; single-window passive
|
||||
confidence is capped below certainty until repeated state earns it.
|
||||
`MimirBioacousticTimeline` is now the active calibration witness for both
|
||||
chirp-only and hybrid: 16 log-spaced motif symbols, three formant-rich
|
||||
syllables per motif, rhythm variation, and an order-3 de Bruijn grammar so
|
||||
any correctly decoded consecutive triplet identifies one canonical timeline
|
||||
location. The analyzer refines final active delay with constrained local
|
||||
chirp-only and hybrid: 128 self-identifying word positions, left/right
|
||||
speaker variants, four formant-rich syllables per word, rhythm variation,
|
||||
and direct word identity so any correctly decoded word identifies one
|
||||
canonical timeline location. The analyzer refines final active delay with constrained local
|
||||
waveform correlation around the decoded anchor delay. Each detected motif
|
||||
carries per-band response evidence, and the next calibration cut should use
|
||||
those profiles to tune contours, formants, usable bands, gain, and rhythm
|
||||
|
|
@ -279,8 +281,8 @@ current_status:
|
|||
loopback, live mic buffers stay populated, runtime sync analysis now runs as
|
||||
a bounded rotating service without UI/telemetry re-entry, and the bioacoustic
|
||||
motif timeline produces deterministic synthetic active sync. The next
|
||||
invariant is code-valid motif triplets producing stable canonical anchors and
|
||||
clock fits through real loopback and microphones, so the actuator can use
|
||||
invariant is self-identifying motif words producing stable canonical anchors
|
||||
and clock fits through real loopback and microphones, so the actuator can use
|
||||
decoded time instead of filtered lag guesses. Replace the remaining
|
||||
diagnostic JSON-line process bridges with direct native capture drivers that
|
||||
push buffer handles into Mimir.Runtime. Mimir.BufferSmoke still proves live buffers and sync reports
|
||||
|
|
|
|||
Loading…
Reference in a new issue