Mimir/src/Mimir.Well/Program.cs

465 lines
16 KiB
C#
Raw Normal View History

2026-06-01 21:27:57 +01:00
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using Mimir.Runtime.Synchronization;
var options = MimirWellOptions.Parse(args);
var runtimeConfig = MimirRuntimeConfiguration.Load();
using var hub = new MimirSynchronizationHub(runtimeConfig.Settings);
var sourceErrors = new List<object>();
foreach (var factory in runtimeConfig.SourceFactories)
{
try
{
var source = factory.Create();
if (source == null)
{
sourceErrors.Add(new { factory.Descriptor.SourceId, status = "not-created" });
continue;
}
hub.AddSource(source);
}
catch (Exception ex)
{
sourceErrors.Add(new
{
factory.Descriptor.SourceId,
status = "create-error",
errorType = ex.GetType().Name,
ex.Message,
});
}
}
using var stopping = new CancellationTokenSource();
if (options.Seconds > 0)
{
stopping.CancelAfter(TimeSpan.FromSeconds(options.Seconds));
}
Console.CancelKeyPress += (_, eventArgs) =>
{
eventArgs.Cancel = true;
stopping.Cancel();
};
await using var publisher = new MimirWellPublisher(options.PublishUrl);
await publisher.ConnectAsync(stopping.Token).ConfigureAwait(false);
var sequence = 0L;
var startedAt = DateTimeOffset.UtcNow;
var nextPublish = DateTimeOffset.MinValue;
var nextSync = DateTimeOffset.MinValue;
2026-06-01 23:52:17 +01:00
var nextVisualCalibration = DateTimeOffset.MinValue;
2026-06-01 21:27:57 +01:00
var presentation = new MimirPresentationControlState();
2026-06-01 23:52:17 +01:00
var exposureController = new MimirCameraExposureController(new MimirCameraExposureControlOptions(
options.VisualCalibrationEnabled,
options.VisualExpectedLedCount,
options.VisualMinimumLuma,
options.VisualSettingSeconds,
options.VisualResweepSeconds));
2026-06-01 21:27:57 +01:00
Console.Error.WriteLine($"Mimir Well publishing to {options.PublishUrl}");
Console.Error.WriteLine($"Mimir Well sources={runtimeConfig.SourceFactories.Count} buffers={hub.Buffers.Buffers.Count}");
while (!stopping.IsCancellationRequested)
{
hub.PollSources(options.MaxSamplesPerSource);
var now = DateTimeOffset.UtcNow;
if (now >= nextSync)
{
if (!string.IsNullOrWhiteSpace(runtimeConfig.Settings.Audio.ReferenceSourceId))
{
hub.AnalyzeAudioSynchronizationStep(
runtimeConfig.Settings.Audio.ReferenceSourceId,
runtimeConfig.Settings.Audio.Mode,
options.SyncCandidatesPerStep);
hub.AnalyzeComplexContourSynchronizationStep(
runtimeConfig.Settings.Audio.ReferenceSourceId,
(now - startedAt).TotalSeconds,
options.SyncCandidatesPerStep);
}
hub.UpdateBioacousticProbeSchedule(NowNs());
nextSync = now + TimeSpan.FromMilliseconds(options.SyncIntervalMs);
}
2026-06-01 23:52:17 +01:00
if (now >= nextVisualCalibration)
{
exposureController.Update(now, hub.Buffers.Buffers, hub.CameraExposureGainActuators);
nextVisualCalibration = now + TimeSpan.FromMilliseconds(options.VisualCalibrationIntervalMs);
}
2026-06-01 21:27:57 +01:00
if (now >= nextPublish)
{
presentation.SyncFromBuffers(hub.Buffers.Buffers);
var frame = BuildFrameOrEmpty(hub, TimeSpan.FromMilliseconds(options.PresentationDelayMs));
var snapshot = MimirWellSnapshot.Build(
options,
runtimeConfig,
hub,
presentation,
frame,
2026-06-01 23:52:17 +01:00
exposureController.Statuses,
2026-06-01 21:27:57 +01:00
sourceErrors,
++sequence,
startedAt);
await publisher.PublishAsync(snapshot, stopping.Token).ConfigureAwait(false);
if (sequence % Math.Max(1, options.MeterEvery) == 0)
{
Console.Error.WriteLine(
$"mimir-well sequence={sequence} ingested={hub.IngestedSamples} ready={frame.Slices.Count(slice => slice.Status == MimirSynchronizedSliceStatus.Ready)}/{frame.Slices.Count}");
}
nextPublish = now + TimeSpan.FromMilliseconds(options.PublishIntervalMs);
}
try
{
await Task.Delay(Math.Max(1, options.PollMs), stopping.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
}
Console.Error.WriteLine($"Mimir Well complete sequence={sequence} ingested={hub.IngestedSamples}");
static long NowNs() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() * 1_000_000L;
static MimirSynchronizedBufferFrame BuildFrameOrEmpty(MimirSynchronizationHub hub, TimeSpan presentationDelay)
{
try
{
return hub.BuildSynchronizedBufferFrame(presentationDelay);
}
catch (ArgumentException ex)
{
Console.Error.WriteLine($"mimir-well synchronized-frame degraded: {ex.Message}");
return new MimirSynchronizedBufferFrame(0, 0, 0, presentationDelay, []);
}
catch (OverflowException ex)
{
Console.Error.WriteLine($"mimir-well synchronized-frame degraded: {ex.Message}");
return new MimirSynchronizedBufferFrame(0, 0, 0, presentationDelay, []);
}
}
internal sealed record MimirWellOptions(
Uri PublishUrl,
string NodeId,
double Seconds,
int PollMs,
int PublishIntervalMs,
int SyncIntervalMs,
int PresentationDelayMs,
int MaxSamplesPerSource,
int SyncCandidatesPerStep,
2026-06-01 23:52:17 +01:00
bool VisualCalibrationEnabled,
int VisualCalibrationIntervalMs,
int VisualExpectedLedCount,
double VisualMinimumLuma,
double VisualSettingSeconds,
double VisualResweepSeconds,
2026-06-01 21:27:57 +01:00
int MeterEvery)
{
public static MimirWellOptions Parse(string[] args) => new(
new Uri(ParseString(args, "--publish-url", "ws://127.0.0.1:8796/eve/periwinkle")),
ParseString(args, "--node-id", Environment.MachineName.ToLowerInvariant()),
ParseDouble(args, "--seconds", 0.0),
ParseInt(args, "--poll-ms", 5),
ParseInt(args, "--publish-ms", 250),
ParseInt(args, "--sync-ms", 250),
ParseInt(args, "--presentation-delay-ms", 2500),
ParseInt(args, "--max-samples-per-source", 4),
ParseInt(args, "--sync-candidates", 1),
2026-06-01 23:52:17 +01:00
ParseBool(args, "--visual-calibration", true),
ParseInt(args, "--visual-calibration-ms", 250),
ParseInt(args, "--visual-expected-leds", 38),
ParseDouble(args, "--visual-minimum-luma", 0.55),
ParseDouble(args, "--visual-setting-seconds", 0.75),
ParseDouble(args, "--visual-resweep-seconds", 12.0),
2026-06-01 21:27:57 +01:00
ParseInt(args, "--meter-every", 20));
private static string ParseString(IReadOnlyList<string> args, string name, string fallback)
{
for (var index = 0; index < args.Count - 1; index++)
{
if (string.Equals(args[index], name, StringComparison.OrdinalIgnoreCase))
{
return args[index + 1];
}
}
return fallback;
}
private static int ParseInt(IReadOnlyList<string> args, string name, int fallback) =>
int.TryParse(ParseString(args, name, ""), out var value) ? value : fallback;
private static double ParseDouble(IReadOnlyList<string> args, string name, double fallback) =>
double.TryParse(ParseString(args, name, ""), out var value) ? value : fallback;
2026-06-01 23:52:17 +01:00
private static bool ParseBool(IReadOnlyList<string> args, string name, bool fallback)
{
for (var index = 0; index < args.Count; index++)
{
if (!string.Equals(args[index], name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (index == args.Count - 1 ||
args[index + 1].StartsWith("--", StringComparison.Ordinal))
{
return true;
}
return bool.TryParse(args[index + 1], out var value) ? value : fallback;
}
return fallback;
}
2026-06-01 21:27:57 +01:00
}
internal sealed class MimirWellPublisher(Uri url) : IAsyncDisposable
{
private readonly ClientWebSocket socket = new();
public async Task ConnectAsync(CancellationToken stopping)
{
await socket.ConnectAsync(url, stopping).ConfigureAwait(false);
}
public async Task PublishAsync(object document, CancellationToken stopping)
{
var json = JsonSerializer.Serialize(document);
var bytes = Encoding.UTF8.GetBytes(json);
await socket.SendAsync(bytes, WebSocketMessageType.Text, endOfMessage: true, stopping).ConfigureAwait(false);
}
public async ValueTask DisposeAsync()
{
if (socket.State == WebSocketState.Open)
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
try
{
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "well-complete", cts.Token).ConfigureAwait(false);
}
catch
{
}
}
socket.Dispose();
}
}
internal static class MimirWellSnapshot
{
public static object Build(
MimirWellOptions options,
MimirRuntimeConfiguration runtimeConfig,
MimirSynchronizationHub hub,
MimirPresentationControlState presentation,
MimirSynchronizedBufferFrame frame,
2026-06-01 23:52:17 +01:00
IReadOnlyList<MimirCameraExposureControlStatus> visualCalibration,
2026-06-01 21:27:57 +01:00
IReadOnlyList<object> sourceErrors,
long sequence,
DateTimeOffset startedAt) => new
{
type = "cultmesh-observation",
document = "mimir.well_snapshot.v1",
sourceId = "mimir-well",
nodeId = options.NodeId,
sequence,
wallClockUtc = DateTimeOffset.UtcNow.ToString("O"),
elapsedSeconds = (DateTimeOffset.UtcNow - startedAt).TotalSeconds,
ingestedSamples = hub.IngestedSamples,
configuredSources = runtimeConfig.SourceFactories.Count,
liveSources = hub.SourceCount,
sourceErrors,
buffers = hub.Buffers.Buffers.Select(BufferSnapshot).ToArray(),
synchronizedFrame = new
{
frame.PresentationTimeNs,
frame.WindowStartNs,
frame.WindowEndNs,
PresentationDelayMs = frame.PresentationDelay.TotalMilliseconds,
frame.IsComplete,
slices = frame.Slices.Select(SliceSnapshot).ToArray(),
},
audioSync = new
{
referenceSourceId = runtimeConfig.Settings.Audio.ReferenceSourceId,
mode = runtimeConfig.Settings.Audio.Mode.ToString(),
complexContour = hub.ComplexContourRuntimeEnabled,
states = hub.AudioSynchronizationStates.Select(state => new
{
state.SourceId,
state.ReferenceSourceId,
state.SampleRate,
state.SmoothedDelaySamples,
state.SamplingRateOffsetPpm,
state.Confidence,
evidenceKind = "audio-sync",
}).ToArray(),
reports = hub.AudioSynchronizationReports.Select(report => new
{
report.SourceId,
report.ReferenceSourceId,
report.EvidenceKind,
report.FractionalDelaySamples,
report.Confidence,
matchedEvents = report.TimelineMatchedEvents,
report.ComparedSamples,
report.AnalysisTimestampNs,
}).ToArray(),
probe = hub.LastBioacousticProbeSchedule is null
? null
: new
{
hub.LastBioacousticProbeSchedule.TimestampNs,
hub.LastBioacousticProbeSchedule.ShouldEmit,
hub.LastBioacousticProbeSchedule.ScheduledIntervalSeconds,
hub.LastBioacousticProbeSchedule.AggregateSyncConfidence,
hub.LastBioacousticProbeSchedule.AggregateFrequencyResponseConfidence,
reason = hub.LastBioacousticProbeSchedule.Reason.ToString(),
2026-06-01 23:52:17 +01:00
},
},
visualCalibration = new
{
enabled = options.VisualCalibrationEnabled,
expectedLedCount = options.VisualExpectedLedCount,
minimumLuma = options.VisualMinimumLuma,
settingSeconds = options.VisualSettingSeconds,
resweepSeconds = options.VisualResweepSeconds,
cameras = visualCalibration.Select(camera => new
{
camera.SourceId,
camera.ControlKind,
camera.SupportsExposureGain,
camera.State,
camera.CurrentSettingId,
camera.CurrentExposure,
camera.CurrentGain,
camera.BestSettingId,
camera.BestExposure,
camera.BestGain,
camera.BestScore,
camera.BestDetectedLedCount,
camera.BestUsableForCalibration,
camera.FramesScored,
camera.LastApplySucceeded,
camera.Reason,
}).ToArray(),
2026-06-01 21:27:57 +01:00
},
composite = new
{
video = presentation.VideoFeeds.Select(feed => new
{
feed.SourceId,
feed.DisplayName,
feed.Enabled,
feed.Solo,
feed.Opacity,
feed.Layer,
}).ToArray(),
audio = presentation.AudioFeeds.Select(feed => new
{
feed.SourceId,
feed.DisplayName,
feed.Muted,
feed.Solo,
feed.Gain,
}).ToArray(),
postprocess = presentation.Postprocess,
},
publication = new
{
MimirObsPublicationConfigurations.NativeProgram.Id,
MimirObsPublicationConfigurations.NativeProgram.VideoKind,
MimirObsPublicationConfigurations.NativeProgram.VideoSourceName,
MimirObsPublicationConfigurations.NativeProgram.AudioKind,
MimirObsPublicationConfigurations.NativeProgram.TargetPresentationDelaySeconds,
stems = MimirObsPublicationConfigurations.NativeProgram.AudioStems.Select(stem => new
{
stem.Id,
stem.DisplayName,
stem.ChannelCount,
stem.UserMixable,
stem.CarriesTimingWitness,
stem.Notes,
}).ToArray(),
},
};
private static object BufferSnapshot(MimirRollingStreamBuffer buffer) => new
{
buffer.Descriptor.SourceId,
Kind = buffer.Descriptor.Kind.ToString(),
Origin = buffer.Descriptor.Origin.ToString(),
buffer.Descriptor.Label,
buffer.Descriptor.EffectiveClockDomainId,
buffer.Count,
buffer.EdgeNs,
buffer.WindowStartNs,
hasLatest = buffer.Latest.HasValue,
latest = buffer.Latest.HasValue ? SampleSnapshot(buffer.Latest.Value) : null,
};
private static object SliceSnapshot(MimirSynchronizedStreamSlice slice) => new
{
slice.SourceId,
Kind = slice.Kind.ToString(),
Origin = slice.Origin.ToString(),
Status = slice.Status.ToString(),
slice.SourceTimestampNs,
slice.CanonicalStartNs,
slice.CanonicalEndNs,
slice.PresentationTimeNs,
slice.TimingOffsetNs,
slice.DistanceFromPresentationNs,
slice.TimingConfidence,
slice.TimingEvidenceKind,
sample = slice.Sample.HasValue ? SampleSnapshot(slice.Sample.Value) : null,
};
private static object SampleSnapshot(MimirStreamSample sample) => new
{
sample.SourceId,
Kind = sample.Kind.ToString(),
Origin = sample.Origin.ToString(),
sample.TimestampNs,
sample.ArrivalNs,
sample.Sequence,
sample.PayloadHandle,
sample.ByteLength,
video = sample.VideoFrame is null ? null : new
{
sample.VideoFrame.Width,
sample.VideoFrame.Height,
PixelFormat = sample.VideoFrame.PixelFormat.ToString(),
sample.VideoFrame.StrideBytes,
sample.VideoFrame.DeviceTimestampNs,
sample.VideoFrame.NativeHandle,
sample.VideoFrame.NativeHandleKind,
sample.VideoFrame.ResourceKey,
sample.VideoFrame.ProducerFenceHandle,
sample.VideoFrame.ProducerFenceValue,
sample.VideoFrame.UnavoidableCopyCount,
},
audio = sample.AudioBlock is null ? null : new
{
sample.AudioBlock.SampleRate,
sample.AudioBlock.Channels,
SampleFormat = sample.AudioBlock.SampleFormat.ToString(),
sample.AudioBlock.FrameCount,
sample.AudioBlock.DeviceTimestampNs,
sample.AudioBlock.NativeHandle,
sample.AudioBlock.NativeHandleKind,
},
};
}