Add chirp-bin watermark decoder

This commit is contained in:
Meta Vens 2026-05-22 19:50:02 +01:00
commit d79bae17bb
8 changed files with 688 additions and 25 deletions

View file

@ -5,6 +5,11 @@ if (args.Any(arg => string.Equals(arg, "--chirplet-self-test", StringComparison.
return RunChirpletSelfTest();
}
if (args.Any(arg => string.Equals(arg, "--chirp-bin-self-test", StringComparison.OrdinalIgnoreCase)))
{
return RunChirpBinSelfTest();
}
if (args.Any(arg => string.Equals(arg, "--passive-sync-self-test", StringComparison.OrdinalIgnoreCase)))
{
return RunPassiveSyncSelfTest();
@ -162,6 +167,41 @@ static int RunChirpletSelfTest()
return 0;
}
static int RunChirpBinSelfTest()
{
var timeline = MimirChirpBinTimeline.Default;
var samples = new List<float>();
for (ulong segment = 0; segment < 6; segment++)
{
samples.AddRange(timeline.RenderSegmentMonoFloat(segment));
}
var decode = timeline.DecodeStreamWindow(samples.ToArray(), MimirChirpBinTimeline.SampleRate);
var meanAbsoluteError = decode.ClockFit?.MeanAbsoluteErrorSamples ?? double.PositiveInfinity;
Console.WriteLine(
$"chirp-bin-self-test frames={decode.Frames.Count} symbols={decode.Symbols.Count} anchors={decode.Anchors.Count} " +
$"clock={(decode.ClockFit is null ? "none" : decode.ClockFit.EffectiveSampleRate.ToString("0.000000"))} " +
$"confidence={(decode.ClockFit?.Confidence ?? 0.0):0.000} mae={meanAbsoluteError:0.000000}");
Console.WriteLine("chirp-bin-expected " + string.Join(",", Enumerable.Range(0, 12).Select(index => timeline.EventForIndex((ulong)index).SymbolId)));
Console.WriteLine("chirp-bin-symbols " + string.Join(",", decode.Symbols.Take(12).Select(symbol => $"{symbol.SymbolId}@{symbol.SampleOffset:0}:{symbol.Energy:0.000}")));
foreach (var anchor in decode.Anchors.Take(16))
{
var expected = timeline.EventForIndex(anchor.EventIndex).StartSeconds * MimirChirpBinTimeline.SampleRate;
Console.WriteLine(
$"chirp-bin-anchor event={anchor.EventIndex} actual={anchor.SampleOffset:0.000} expected={expected:0.000} " +
$"error={anchor.SampleOffset - expected:0.000} confidence={anchor.Confidence:0.000}");
}
if (decode.ClockFit == null || decode.Anchors.Count < 16 || meanAbsoluteError > 2.0)
{
Console.Error.WriteLine("chirp-bin self-test failed: dechirp/bin decoder did not recover stable timeline anchors");
return 1;
}
return 0;
}
static int RunPassiveSyncSelfTest()
{
const int sampleRate = 48_000;

View file

@ -156,14 +156,18 @@ public sealed class MimirRuntime : IAquariumRuntime
}
var segmentCount = audioSyncSettings.Mode == MimirAudioSyncMode.Hybrid ? 1 : CalibrationBatchSegments;
var batch = RenderCalibrationBatchPcm16Base64(calibrationSegmentIndex, segmentCount, out var peak);
var batch = RenderCalibrationBatchPcm16Base64(
calibrationSegmentIndex,
segmentCount,
audioSyncSettings.Mode == MimirAudioSyncMode.Hybrid,
out var peak);
visualRuntime.Audio.EnqueuePcm16Base64(
batch,
MimirChirpletTimeline.SampleRate,
channels: 1,
gain: calibrationGain);
Console.WriteLine(
$"mimir-chirplet-batch firstSegment={calibrationSegmentIndex} segments={segmentCount} seconds={segmentCount * MimirChirpletTimeline.SegmentSeconds:0.00} peak={peak:0.000000} gain={calibrationGain:0.###} base64Bytes={batch.Length}");
$"mimir-chirplet-batch mode={DescribeAudioSyncMode()} firstSegment={calibrationSegmentIndex} segments={segmentCount} seconds={segmentCount * MimirChirpletTimeline.SegmentSeconds:0.00} peak={peak:0.000000} gain={calibrationGain:0.###} base64Bytes={batch.Length}");
calibrationSegmentIndex += (ulong)segmentCount;
}
@ -178,7 +182,11 @@ public sealed class MimirRuntime : IAquariumRuntime
return $"{audioSyncSettings.ReferenceSourceId} {DescribeAudioSyncMode()} timeline {MimirChirpletTimeline.SegmentSeconds:0.00}s segments emitted to {emittedUntilSeconds:0.00}s passiveConfidence={lastPassiveSynchronizationConfidence:0.000}";
}
private static string RenderCalibrationBatchPcm16Base64(ulong firstSegment, int segmentCount, out float peak)
private static string RenderCalibrationBatchPcm16Base64(
ulong firstSegment,
int segmentCount,
bool useChirpBinTimeline,
out float peak)
{
var samplesPerSegment = (int)Math.Round(MimirChirpletTimeline.SegmentSeconds * MimirChirpletTimeline.SampleRate);
var bytes = new byte[samplesPerSegment * Math.Max(1, segmentCount) * sizeof(short)];
@ -186,7 +194,9 @@ public sealed class MimirRuntime : IAquariumRuntime
peak = 0.0f;
for (var segment = 0; segment < segmentCount; segment++)
{
var samples = MimirChirpletTimeline.Default.RenderSegmentMonoFloat(firstSegment + (ulong)segment);
var samples = useChirpBinTimeline
? MimirChirpBinTimeline.Default.RenderSegmentMonoFloat(firstSegment + (ulong)segment)
: MimirChirpletTimeline.Default.RenderSegmentMonoFloat(firstSegment + (ulong)segment);
for (var index = 0; index < samples.Length; index++)
{
peak = Math.Max(peak, Math.Abs(samples[index]));

View file

@ -152,8 +152,12 @@ public sealed class MimirAudioSynchronizationAnalyzer
}
}
var comparedReferenceDecode = MimirChirpletTimeline.Default.DecodeStreamWindow(referenceWindow, activeReferenceBlock.SampleRate);
var candidateDecode = MimirChirpletTimeline.Default.DecodeStreamWindow(candidateWindow, activeReferenceBlock.SampleRate);
var comparedReferenceDecode = mode == MimirAudioSyncMode.Hybrid
? MimirChirpBinTimeline.Default.DecodeStreamWindow(referenceWindow, activeReferenceBlock.SampleRate)
: MimirChirpletTimeline.Default.DecodeStreamWindow(referenceWindow, activeReferenceBlock.SampleRate);
var candidateDecode = mode == MimirAudioSyncMode.Hybrid
? MimirChirpBinTimeline.Default.DecodeStreamWindow(candidateWindow, activeReferenceBlock.SampleRate)
: MimirChirpletTimeline.Default.DecodeStreamWindow(candidateWindow, activeReferenceBlock.SampleRate);
var deterministicFit = EstimateDelayFromDecodedTimeline(comparedReferenceDecode, candidateDecode);
lastDecodeTraces.Add(new MimirAudioSynchronizationDecodeTrace(
reference.Descriptor.SourceId,
@ -177,7 +181,9 @@ public sealed class MimirAudioSynchronizationAnalyzer
}
var decodedDelaySamples = deterministicFit.DelaySamples;
var bandResponses = MimirChirpletTimeline.Default.EstimateBandResponse(candidateWindow, activeReferenceBlock.SampleRate);
var bandResponses = mode == MimirAudioSyncMode.Hybrid
? []
: MimirChirpletTimeline.Default.EstimateBandResponse(candidateWindow, activeReferenceBlock.SampleRate);
reports.Add(new MimirAudioSynchronizationReport(
reference.Descriptor.SourceId,
buffer.Descriptor.SourceId,
@ -193,7 +199,7 @@ public sealed class MimirAudioSynchronizationAnalyzer
buffer.Latest?.Sequence ?? 0,
deterministicFit.MatchedEvents,
deterministicFit.Confidence,
"chirplet"));
mode == MimirAudioSyncMode.Hybrid ? "chirp-bin" : "chirplet"));
}
return reports;

View file

@ -0,0 +1,596 @@
using System.Numerics;
namespace Mimir.Runtime.Synchronization;
public sealed record MimirChirpBinSymbolDefinition(
int SymbolId,
double OffsetHz);
public sealed class MimirChirpBinTimeline
{
public const int SampleRate = 48_000;
public const double SegmentSeconds = 0.5;
public const int SymbolCount = 32;
public const int TimelineOrder = 3;
private const double FirstEventSeconds = 0.08;
private const double EventSpacingSeconds = 0.125;
private const double ChirpDurationSeconds = 0.064;
private const double BaseStartHz = 7_600.0;
private const double BaseEndHz = 14_800.0;
private const double BinSpacingHz = 62.5;
private const double Gain = 0.070;
private const int MaxSymbolCandidatesPerFrame = 6;
private static readonly int[] TimelineSymbols = RotateToDistinctOpening(BuildDeBruijn(SymbolCount, TimelineOrder));
private static readonly Dictionary<int, int> TripleToIndex = BuildTripleIndex(TimelineSymbols);
private static readonly MimirChirpBinSymbolDefinition[] Symbols = BuildSymbols();
public static MimirChirpBinTimeline Default { get; } = new();
public IReadOnlyList<MimirChirpBinSymbolDefinition> Codebook => Symbols;
public float[] RenderSegmentMonoFloat(ulong segmentIndex)
{
var segmentStartSeconds = segmentIndex * SegmentSeconds;
var samples = new float[(int)Math.Round(SegmentSeconds * SampleRate)];
foreach (var timelineEvent in EventsOverlapping(segmentStartSeconds, SegmentSeconds))
{
AddChirp(samples, SampleRate, timelineEvent, segmentStartSeconds);
}
return samples;
}
public MimirChirpletStreamDecode DecodeStreamWindow(ReadOnlySpan<float> samples, int sampleRate)
{
if (samples.Length == 0)
{
return new MimirChirpletStreamDecode([], [], [], null);
}
var frames = DetectFrames(samples, sampleRate);
var symbols = frames
.Select(frame => new MimirChirpletSymbolObservation(
frame.BestCandidate.SymbolId,
frame.SampleOffset,
frame.BestCandidate.Energy))
.ToArray();
var anchors = DecodeAnchors(frames, sampleRate);
var clock = FitClock(anchors, sampleRate);
return new MimirChirpletStreamDecode(frames, symbols, anchors, clock);
}
public MimirChirpletTimelineEvent EventForIndex(ulong eventIndex)
{
var symbolId = SymbolForEvent(eventIndex);
var startSeconds = EventStartSeconds(eventIndex);
var symbol = Symbols[symbolId];
return new MimirChirpletTimelineEvent(
eventIndex,
symbolId,
startSeconds,
new MimirChirpletTone(
startSeconds,
ChirpDurationSeconds,
BaseStartHz + symbol.OffsetHz,
BaseEndHz + symbol.OffsetHz,
Gain));
}
public IReadOnlyList<MimirChirpletTimelineEvent> EventsOverlapping(double startSeconds, double durationSeconds)
{
var endSeconds = startSeconds + durationSeconds;
var firstIndex = Math.Max(0, (long)Math.Floor((startSeconds - FirstEventSeconds - ChirpDurationSeconds) / EventSpacingSeconds) - 2);
var lastIndex = Math.Max(firstIndex, (long)Math.Ceiling((endSeconds - FirstEventSeconds) / EventSpacingSeconds) + 2);
var events = new List<MimirChirpletTimelineEvent>((int)(lastIndex - firstIndex + 1));
for (var eventIndex = firstIndex; eventIndex <= lastIndex; eventIndex++)
{
var timelineEvent = EventForIndex((ulong)eventIndex);
if (timelineEvent.StartSeconds < endSeconds &&
timelineEvent.StartSeconds + ChirpDurationSeconds > startSeconds)
{
events.Add(timelineEvent);
}
}
return events;
}
private static IReadOnlyList<MimirChirpletTransformFrame> DetectFrames(ReadOnlySpan<float> samples, int sampleRate)
{
var chirpSamples = Math.Max(1, (int)Math.Round(ChirpDurationSeconds * sampleRate));
if (samples.Length < chirpSamples)
{
return [];
}
var hopSamples = Math.Max(1, sampleRate / 400);
var energyTrace = BuildEnergyTrace(samples, chirpSamples, hopSamples);
var threshold = AdaptiveThreshold(energyTrace);
var proposals = new List<int>();
for (var index = 1; index < energyTrace.Length - 1; index++)
{
if (energyTrace[index] >= threshold &&
energyTrace[index] >= energyTrace[index - 1] &&
energyTrace[index] >= energyTrace[index + 1])
{
proposals.Add(index * hopSamples);
}
}
var frames = new List<MimirChirpletTransformFrame>();
foreach (var proposal in proposals)
{
var frame = ClassifyAt(samples, sampleRate, proposal, sampleRate / 120);
if (frame != null)
{
frames.Add(frame);
}
}
return SuppressNearbyFrames(frames, sampleRate);
}
private static MimirChirpletTransformFrame? ClassifyAt(
ReadOnlySpan<float> samples,
int sampleRate,
int predictedOffset,
int searchRadiusSamples)
{
var chirpSamples = Math.Max(1, (int)Math.Round(ChirpDurationSeconds * sampleRate));
if (samples.Length < chirpSamples)
{
return null;
}
var start = Math.Max(0, predictedOffset - searchRadiusSamples);
var end = Math.Min(samples.Length - chirpSamples, predictedOffset + searchRadiusSamples);
var bestOffset = predictedOffset;
MimirChirpletSymbolCandidate[] bestCandidates = [];
var bestEnergy = 0.0;
var step = Math.Max(2, searchRadiusSamples / 24);
for (var offset = start; offset <= end; offset += step)
{
var candidates = ScoreBins(samples.Slice(offset, chirpSamples), sampleRate, offset);
var energy = candidates.Length == 0 ? 0.0 : candidates[0].Energy;
if (energy > bestEnergy)
{
bestEnergy = energy;
bestOffset = offset;
bestCandidates = candidates;
}
}
var localStart = Math.Max(start, bestOffset - step);
var localEnd = Math.Min(end, bestOffset + step);
for (var offset = localStart; offset <= localEnd; offset++)
{
var candidates = ScoreBins(samples.Slice(offset, chirpSamples), sampleRate, offset);
var energy = candidates.Length == 0 ? 0.0 : candidates[0].Energy;
if (energy > bestEnergy)
{
bestEnergy = energy;
bestOffset = offset;
bestCandidates = candidates;
}
}
if (bestCandidates.Length == 0 || bestEnergy < 0.11)
{
return null;
}
return new MimirChirpletTransformFrame(bestOffset, bestCandidates);
}
private static MimirChirpletSymbolCandidate[] ScoreBins(
ReadOnlySpan<float> samples,
int sampleRate,
int sampleOffset)
{
var scores = new MimirChirpletSymbolCandidate[Symbols.Length];
var sampleEnergy = 0.0;
var referenceEnergy = 0.0;
for (var index = 0; index < samples.Length; index++)
{
sampleEnergy += samples[index] * samples[index];
var normalized = samples.Length <= 1 ? 1.0 : index / (double)(samples.Length - 1);
var window = 0.5 - 0.5 * Math.Cos(2.0 * Math.PI * normalized);
referenceEnergy += window * window * 0.5;
}
if (sampleEnergy <= 1.0e-12 || referenceEnergy <= 1.0e-12)
{
return [];
}
for (var symbol = 0; symbol < Symbols.Length; symbol++)
{
var score = GoertzelDechirpedBin(samples, sampleRate, Symbols[symbol].OffsetHz);
scores[symbol] = new MimirChirpletSymbolCandidate(
symbol,
sampleOffset,
2.0 * score / Math.Sqrt(sampleEnergy * referenceEnergy));
}
return scores
.OrderByDescending(candidate => candidate.Energy)
.Take(MaxSymbolCandidatesPerFrame)
.ToArray();
}
private static double GoertzelDechirpedBin(ReadOnlySpan<float> samples, int sampleRate, double offsetHz)
{
var real = 0.0;
var imaginary = 0.0;
for (var index = 0; index < samples.Length; index++)
{
var t = index / (double)sampleRate;
var normalized = samples.Length <= 1 ? 1.0 : index / (double)(samples.Length - 1);
var window = 0.5 - 0.5 * Math.Cos(2.0 * Math.PI * normalized);
var basePhase = BasePhase(t);
var binPhase = 2.0 * Math.PI * offsetHz * t;
var phase = -(basePhase + binPhase);
var value = samples[index] * window;
real += value * Math.Cos(phase);
imaginary += value * Math.Sin(phase);
}
return Math.Sqrt(real * real + imaginary * imaginary);
}
private static IReadOnlyList<MimirChirpletTimelineAnchor> DecodeAnchors(
IReadOnlyList<MimirChirpletTransformFrame> frames,
int sampleRate)
{
if (frames.Count < TimelineOrder)
{
return [];
}
var candidates = new List<MimirChirpletTimelineAnchor>();
for (var index = 0; index <= frames.Count - TimelineOrder; index++)
{
var firstFrame = frames[index];
var secondFrame = frames[index + 1];
var thirdFrame = frames[index + 2];
if (!IsConsecutive(firstFrame, secondFrame, sampleRate) ||
!IsConsecutive(secondFrame, thirdFrame, sampleRate))
{
continue;
}
foreach (var first in firstFrame.Candidates)
foreach (var second in secondFrame.Candidates)
foreach (var third in thirdFrame.Candidates)
{
var code = TripleCode(first.SymbolId, second.SymbolId, third.SymbolId);
if (!TripleToIndex.TryGetValue(code, out var eventIndex))
{
continue;
}
var firstEvent = Default.EventForIndex((ulong)eventIndex);
var measuredGapA = (second.SampleOffset - first.SampleOffset) / sampleRate;
var measuredGapB = (third.SampleOffset - second.SampleOffset) / sampleRate;
var gapError = Math.Abs(measuredGapA - EventSpacingSeconds) + Math.Abs(measuredGapB - EventSpacingSeconds);
var gapConfidence = 1.0 / (1.0 + gapError / 0.003);
if (gapConfidence < 0.55)
{
continue;
}
var energyConfidence = Math.Clamp((first.Energy + second.Energy + third.Energy) / 3.0, 0.0, 1.0);
candidates.Add(new MimirChirpletTimelineAnchor(
(ulong)eventIndex,
firstEvent.StartSeconds,
first.SampleOffset,
gapConfidence * 0.60 + energyConfidence * 0.40,
[
new MimirChirpletSymbolObservation(first.SymbolId, first.SampleOffset, first.Energy),
new MimirChirpletSymbolObservation(second.SymbolId, second.SampleOffset, second.Energy),
new MimirChirpletSymbolObservation(third.SymbolId, third.SampleOffset, third.Energy),
]));
}
}
return SelectCoherentAnchorPath(candidates, sampleRate);
}
private static IReadOnlyList<MimirChirpletTimelineAnchor> SelectCoherentAnchorPath(
IReadOnlyList<MimirChirpletTimelineAnchor> candidates,
int sampleRate)
{
if (candidates.Count == 0)
{
return [];
}
List<MimirChirpletTimelineAnchor> bestPath = [];
var bestScore = double.NegativeInfinity;
foreach (var seed in candidates.OrderByDescending(anchor => anchor.Confidence).Take(64))
{
var seedOffset = seed.SampleOffset - seed.TimelineSeconds * sampleRate;
var path = candidates
.Where(anchor => Math.Abs((anchor.SampleOffset - anchor.TimelineSeconds * sampleRate) - seedOffset) <= sampleRate * 0.006)
.GroupBy(anchor => anchor.EventIndex)
.Select(group => group.OrderByDescending(anchor => anchor.Confidence).First())
.OrderBy(anchor => anchor.EventIndex)
.ToList();
var clock = FitClock(path, sampleRate);
if (clock == null)
{
continue;
}
var score = path.Sum(anchor => anchor.Confidence) +
Math.Min(path.Count, 12) * 0.20 -
clock.MeanAbsoluteErrorSamples / Math.Max(1.0, sampleRate * 0.001);
if (score > bestScore)
{
bestScore = score;
bestPath = path;
}
}
var finalClock = FitClock(bestPath, sampleRate);
if (finalClock == null)
{
return [];
}
return bestPath
.Where(anchor => Math.Abs(anchor.SampleOffset - finalClock.SampleForTimelineSeconds(anchor.TimelineSeconds)) <= Math.Max(16.0, sampleRate * 0.0015))
.OrderBy(anchor => anchor.SampleOffset)
.ToArray();
}
private static MimirChirpletClockFit? FitClock(
IReadOnlyList<MimirChirpletTimelineAnchor> anchors,
int sampleRate)
{
if (anchors.Count == 0)
{
return null;
}
if (anchors.Count == 1)
{
var anchor = anchors[0];
return new MimirChirpletClockFit(
anchor.SampleOffset - anchor.TimelineSeconds * sampleRate,
sampleRate,
anchor.Confidence * 0.35,
1,
0.0);
}
var totalWeight = anchors.Sum(anchor => Math.Max(1.0e-6, anchor.Confidence));
var meanTimeline = anchors.Sum(anchor => anchor.TimelineSeconds * Math.Max(1.0e-6, anchor.Confidence)) / totalWeight;
var meanSample = anchors.Sum(anchor => anchor.SampleOffset * Math.Max(1.0e-6, anchor.Confidence)) / totalWeight;
var covariance = 0.0;
var variance = 0.0;
foreach (var anchor in anchors)
{
var weight = Math.Max(1.0e-6, anchor.Confidence);
var dt = anchor.TimelineSeconds - meanTimeline;
covariance += weight * dt * (anchor.SampleOffset - meanSample);
variance += weight * dt * dt;
}
var effectiveSampleRate = variance > 1.0e-12 ? covariance / variance : sampleRate;
if (!double.IsFinite(effectiveSampleRate) ||
effectiveSampleRate < sampleRate * 0.98 ||
effectiveSampleRate > sampleRate * 1.02)
{
effectiveSampleRate = sampleRate;
}
var sourceOffset = meanSample - effectiveSampleRate * meanTimeline;
var meanAbsoluteError = anchors.Sum(anchor =>
{
var weight = Math.Max(1.0e-6, anchor.Confidence);
var predicted = sourceOffset + anchor.TimelineSeconds * effectiveSampleRate;
return Math.Abs(anchor.SampleOffset - predicted) * weight;
}) / totalWeight;
var residualConfidence = 1.0 / (1.0 + meanAbsoluteError / Math.Max(1.0, sampleRate * 0.00075));
var countConfidence = Math.Clamp(anchors.Count / 12.0, 0.0, 1.0);
var anchorConfidence = Math.Clamp(anchors.Average(anchor => anchor.Confidence), 0.0, 1.0);
return new MimirChirpletClockFit(
sourceOffset,
effectiveSampleRate,
residualConfidence * 0.45 + countConfidence * 0.25 + anchorConfidence * 0.30,
anchors.Count,
meanAbsoluteError);
}
private static float[] BuildEnergyTrace(ReadOnlySpan<float> samples, int windowSamples, int hopSamples)
{
var output = new float[1 + (samples.Length - windowSamples) / hopSamples];
var energy = 0.0;
for (var index = 0; index < windowSamples; index++)
{
energy += samples[index] * samples[index];
}
output[0] = (float)Math.Sqrt(energy / windowSamples);
for (var frame = 1; frame < output.Length; frame++)
{
var previousStart = (frame - 1) * hopSamples;
var nextStart = frame * hopSamples;
for (var index = previousStart; index < nextStart; index++)
{
energy -= samples[index] * samples[index];
}
for (var index = previousStart + windowSamples; index < nextStart + windowSamples; index++)
{
energy += samples[index] * samples[index];
}
output[frame] = (float)Math.Sqrt(Math.Max(0.0, energy) / windowSamples);
}
return output;
}
private static double AdaptiveThreshold(float[] energyTrace)
{
if (energyTrace.Length == 0)
{
return double.PositiveInfinity;
}
var mean = energyTrace.Average(value => (double)value);
var variance = energyTrace.Sum(value => (value - mean) * (value - mean)) / energyTrace.Length;
return mean + Math.Sqrt(Math.Max(0.0, variance)) * 0.75;
}
private static IReadOnlyList<MimirChirpletTransformFrame> SuppressNearbyFrames(
IReadOnlyList<MimirChirpletTransformFrame> frames,
int sampleRate)
{
var minimumSpacingSamples = EventSpacingSeconds * sampleRate * 0.65;
var kept = new List<MimirChirpletTransformFrame>();
foreach (var frame in frames.OrderByDescending(frame => frame.BestCandidate.Energy))
{
if (kept.Any(existing => Math.Abs(existing.SampleOffset - frame.SampleOffset) < minimumSpacingSamples))
{
continue;
}
kept.Add(frame);
}
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.70 && seconds <= EventSpacingSeconds * 1.30;
}
private static void AddChirp(
float[] samples,
int sampleRate,
MimirChirpletTimelineEvent timelineEvent,
double segmentStartSeconds)
{
var symbol = Symbols[timelineEvent.SymbolId];
var startFrame = (int)Math.Round((timelineEvent.StartSeconds - segmentStartSeconds) * sampleRate);
var frameCount = Math.Max(1, (int)Math.Round(ChirpDurationSeconds * sampleRate));
for (var frame = 0; frame < frameCount; frame++)
{
var outputFrame = startFrame + frame;
if (outputFrame < 0 || outputFrame >= samples.Length)
{
continue;
}
var normalized = frameCount <= 1 ? 1.0 : frame / (double)(frameCount - 1);
var t = frame / (double)sampleRate;
var envelope = 0.5 - 0.5 * Math.Cos(2.0 * Math.PI * normalized);
var phase = BasePhase(t) + 2.0 * Math.PI * symbol.OffsetHz * t;
samples[outputFrame] += (float)(Math.Sin(phase) * envelope * Gain);
}
}
private static double BasePhase(double t)
{
var slope = (BaseEndHz - BaseStartHz) / ChirpDurationSeconds;
return 2.0 * Math.PI * (BaseStartHz * t + 0.5 * slope * t * t);
}
private static MimirChirpBinSymbolDefinition[] BuildSymbols()
{
var symbols = new MimirChirpBinSymbolDefinition[SymbolCount];
var firstOffset = -(SymbolCount - 1) * BinSpacingHz * 0.5;
for (var symbol = 0; symbol < symbols.Length; symbol++)
{
symbols[symbol] = new MimirChirpBinSymbolDefinition(symbol, firstOffset + symbol * BinSpacingHz);
}
return symbols;
}
private static int SymbolForEvent(ulong eventIndex) =>
TimelineSymbols[(int)(eventIndex % (ulong)TimelineSymbols.Length)];
private static double EventStartSeconds(ulong eventIndex) =>
FirstEventSeconds + eventIndex * EventSpacingSeconds;
private static int[] BuildDeBruijn(int alphabetSize, int order)
{
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();
}
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<int, int> BuildTripleIndex(IReadOnlyList<int> symbols)
{
var map = new Dictionary<int, int>(symbols.Count);
for (var index = 0; index < symbols.Count; index++)
{
var code = TripleCode(
symbols[index],
symbols[(index + 1) % symbols.Count],
symbols[(index + 2) % symbols.Count]);
if (!map.ContainsKey(code))
{
map[code] = index;
}
}
return map;
}
private static int TripleCode(int first, int second, int third) =>
first * SymbolCount * SymbolCount + second * SymbolCount + third;
}