Add Raven mux OBS sink

This commit is contained in:
Meta Vens 2026-06-07 17:42:17 +01:00
commit 0cc1414abf
5 changed files with 134 additions and 34 deletions

View file

@ -18,10 +18,16 @@ Inputs become outputs like this:
6. Each process sends MPEG-TS over SRT to a stable receiver URL.
7. OBS adds each URL as a Media Source.
`Mimir.RavenDaemon` is the current Raven-local supervisor for the combined
display plus Realtek loopback mux. It emits named SRT sinks rather than one
anonymous stream: Mimir receives the canonical ingest copy on `5200`, and OBS
receives an ordinary media-source copy on `5204`.
## Invariants
- Video encoding happens on the sender.
- OBS receives ordinary media-source URLs; it does not need a plugin for v1.
- Mimir and OBS do not contend for the same SRT listener.
- Audio remains separately mixable in OBS.
- Ports are stable and derived from one base port plus explicit offsets.
- Secrets, if used, stay in local config and are not committed.

View file

@ -5,12 +5,12 @@ Raven owns local display capture and Realtek render-loopback capture. Mimir rece
## Authority Map
- Owner: `Mimir.RavenDaemon` owns process supervision and typed status for Raven's capture mux.
- Inputs: local display capture parameters, WASAPI render-loopback selection, FFmpeg path, SRT target, log root, and operator flags.
- Outputs: `mimir.raven_capture_mux_state.v1`, an Eve dashboard surface, health JSON, and the FFmpeg SRT MPEG-TS stream.
- Inputs: local display capture parameters, WASAPI render-loopback selection, FFmpeg path, named SRT targets, log root, and operator flags.
- Outputs: `mimir.raven_capture_mux_state.v1`, an Eve dashboard surface, health JSON, and named FFmpeg SRT MPEG-TS streams for Mimir and OBS.
- Derived state: PID, restart count, log paths, and dashboard nodes are derived from the supervised process and daemon options.
- Forbidden writers: capture scripts may still launch diagnostics, but they do not own daemon status or the canonical Raven mux state.
- Shared paths: service launch, dry run, health checks, and Eve dashboard projection all read the same `MimirRavenCaptureMuxStateDocument`.
- Cut line: no OBS plugin, custom media daemon, or alternate transport owns media in this pass. FFmpeg/WASAPI own capture and mux; CultMesh owns status and operator surface.
- Cut line: no OBS plugin, custom media daemon, or alternate transport owns media in this pass. FFmpeg/WASAPI own capture, mux, encode, and SRT fanout; CultMesh owns status and operator surface.
## Run On Raven
@ -22,7 +22,8 @@ From a Mimir checkout on Raven:
Defaults:
- Target: `srt://10.77.0.2:5200`
- Mimir target: `srt://10.77.0.2:5200`
- OBS target: `srt://10.77.0.2:5204`
- Eve/CultMesh dashboard: `ws://0.0.0.0:8801/eve/deck`
- Binary CultMesh dashboard stream: `ws://0.0.0.0:8801/eve/deck/cultmesh`
- Health: `http://127.0.0.1:8801/health`
@ -35,6 +36,12 @@ Use a dry run to inspect the exact FFmpeg pipeline without starting capture:
.\scripts\start-raven-daemon.ps1 -DryRun
```
Disable the OBS sink when only Mimir should receive the mux:
```powershell
.\scripts\start-raven-daemon.ps1 -NoObsTarget
```
Use a specific Realtek render endpoint when Windows exposes more than one:
```powershell
@ -49,9 +56,25 @@ If Raven already has a host-level CultMesh server bound, keep this daemon as a l
## Receiver Shape
The daemon sends one MPEG-TS SRT stream containing:
The daemon sends identical MPEG-TS SRT streams containing:
- `raven-display`: Raven desktop via `ddagrab` or `gdigrab`, encoded with `h264_nvenc`
- `raven-realtk-loopback`: Raven render loopback via `Mimir.WasapiLoopback` or the PowerShell WASAPI fallback, encoded as AAC
Existing demux/receiver tooling can split that stream back into the video and audio source lanes. The typo in the existing source id, `raven-realtk-loopback`, is preserved until the receiver config is migrated.
Mimir receives the ingest copy on `5200`. `scripts/start-raven-av-demux.ps1`
can split that copy back into local video and audio source lanes for the
current raw ingest adapters. OBS receives its own copy on `5204` as an ordinary
SRT Media Source; it does not compete with Mimir for the `5200` listener.
The typo in the existing source id, `raven-realtk-loopback`, is preserved until the receiver config is migrated.
## Idunn Lifecycle
Idunn watches the Raven daemon from Odin's local keepalive body:
- Health: `E:\Projects\Odin\scripts\health-raven-capture-mux.cmd`
- Restart: `E:\Projects\Odin\scripts\restart-raven-capture-mux.cmd`
- Default SSH target: Raven's WireGuard address, `10.77.0.4`
If Raven is unreachable, Idunn should record the failed health probe and raise
the normal keepalive decision instead of pretending the daemon is healthy.

View file

@ -1,6 +1,8 @@
param(
[string]$TargetHost = "10.77.0.2",
[int]$Port = 5200,
[string]$ObsTargetHost = "",
[int]$ObsPort = 5204,
[int]$EvePort = 8801,
[int]$Width = 1920,
[int]$Height = 1080,
@ -15,6 +17,7 @@ param(
[string]$WasapiLoopbackPath = "",
[string]$CultMeshCachePath = "C:\Meta\Mimir\state\raven-capture-mux.ccmp",
[string]$LogRoot = "C:\Meta\Mimir\logs",
[switch]$NoObsTarget,
[switch]$NoCultNetServer,
[switch]$DryRun
)
@ -22,6 +25,9 @@ param(
$ErrorActionPreference = "Stop"
$repo = Split-Path -Parent $PSScriptRoot
if ([string]::IsNullOrWhiteSpace($ObsTargetHost)) {
$ObsTargetHost = $TargetHost
}
$project = Join-Path $repo "src\Mimir.RavenDaemon\Mimir.RavenDaemon.csproj"
$runtimeArgs = @(
"run",
@ -29,6 +35,8 @@ $runtimeArgs = @(
"--",
"--target-host", $TargetHost,
"--port", $Port,
"--obs-target-host", $ObsTargetHost,
"--obs-port", $ObsPort,
"--eve-port", $EvePort,
"--width", $Width,
"--height", $Height,
@ -43,6 +51,10 @@ $runtimeArgs = @(
"--log-root", $LogRoot
)
if ($NoObsTarget) {
$runtimeArgs += "--no-obs-target"
}
if (-not [string]::IsNullOrWhiteSpace($WasapiLoopbackPath)) {
$runtimeArgs += @("--wasapi-loopback", $WasapiLoopbackPath)
}
@ -74,7 +86,10 @@ $process = Start-Process `
Write-Host "Started Mimir.RavenDaemon pid=$($process.Id)"
Write-Host " Eve/CultMesh: ws://0.0.0.0:${EvePort}/eve/deck"
Write-Host " Health: http://127.0.0.1:${EvePort}/health"
Write-Host " Target: srt://${TargetHost}:${Port}"
Write-Host " Mimir target: srt://${TargetHost}:${Port}"
if (-not $NoObsTarget) {
Write-Host " OBS target: srt://${ObsTargetHost}:${ObsPort}"
}
Write-Host " CultMesh cache: $CultMeshCachePath"
Write-Host " stdout: $stdoutLog"
Write-Host " stderr: $stderrLog"

View file

@ -23,7 +23,7 @@ Console.CancelKeyPress += (_, eventArgs) =>
};
var command = RavenMuxCommand.Build(options);
await using var state = await RavenCaptureMuxState.OpenAsync(options, command.CommandLine).ConfigureAwait(false);
await using var state = await RavenCaptureMuxState.OpenAsync(options, command).ConfigureAwait(false);
using var server = new RavenDaemonEveServer(options, state);
if (options.DryRun)
@ -46,7 +46,7 @@ if (options.DryRun)
Console.Error.WriteLine($"Mimir Raven daemon state cache {options.CultMeshCachePath}");
Console.Error.WriteLine($"Mimir Raven daemon speaking Eve/CultMesh on ws://0.0.0.0:{options.EvePort}/eve/deck");
Console.Error.WriteLine($"Mimir Raven mux target {command.Endpoint}");
Console.Error.WriteLine($"Mimir Raven mux targets {string.Join(", ", command.Targets.Select(static target => target.Name + "=" + target.Endpoint))}");
var serverTask = server.RunAsync(stopping.Token);
var supervisorTask = RavenMuxSupervisor.RunAsync(options, command, state, stopping.Token);
@ -57,6 +57,9 @@ internal sealed record RavenDaemonOptions(
string HostId,
string TargetHost,
int Port,
string ObsTargetHost,
int ObsPort,
bool EnableObsTarget,
int EvePort,
string CultMeshCachePath,
string LogRoot,
@ -81,11 +84,15 @@ internal sealed record RavenDaemonOptions(
{
public static RavenDaemonOptions Parse(string[] args)
{
var targetHost = Text(args, "--target-host", "10.77.0.2");
return new RavenDaemonOptions(
DaemonId: Text(args, "--daemon-id", "mimir.raven.capture-mux"),
HostId: Text(args, "--host-id", "raven"),
TargetHost: Text(args, "--target-host", "10.77.0.2"),
TargetHost: targetHost,
Port: Int(args, "--port", 5200),
ObsTargetHost: Text(args, "--obs-target-host", targetHost),
ObsPort: Int(args, "--obs-port", 5204),
EnableObsTarget: !Flag(args, "--no-obs-target"),
EvePort: Int(args, "--eve-port", 8801),
CultMeshCachePath: Text(args, "--cultmesh-cache", @"C:\Meta\Mimir\state\raven-capture-mux.ccmp"),
LogRoot: Text(args, "--log-root", @"C:\Meta\Mimir\logs"),
@ -132,16 +139,16 @@ internal sealed record RavenDaemonOptions(
}
}
internal sealed record RavenMuxCommand(string CommandLine, string Endpoint, string StdoutLog, string StderrLog)
internal sealed record RavenMuxTarget(string Name, string Endpoint);
internal sealed record RavenMuxCommand(string CommandLine, IReadOnlyList<RavenMuxTarget> Targets, string StdoutLog, string StderrLog)
{
public static RavenMuxCommand Build(RavenDaemonOptions options)
{
var timestamp = DateTimeOffset.UtcNow.ToString("yyyyMMdd-HHmmss");
var stdoutLog = Path.Combine(options.LogRoot, $"raven-av-srt-{timestamp}.out.log");
var stderrLog = Path.Combine(options.LogRoot, $"raven-av-srt-{timestamp}.err.log");
var endpoint = options.Transport == "tcp-listener"
? $"tcp://{options.TargetHost}:{options.Port}?listen=1"
: $"srt://{options.TargetHost}:{options.Port}?mode={options.SrtMode}&latency=120000&timeout=30000000";
var targets = BuildTargets(options);
var repoRoot = FindRepoRoot();
var loopback = ResolveLoopbackCommand(options, repoRoot);
var ffmpeg = new List<string>
@ -223,13 +230,42 @@ internal sealed record RavenMuxCommand(string CommandLine, string Endpoint, stri
options.AudioSampleRate.ToString(),
"-ac",
options.AudioChannels.ToString(),
"-f",
"mpegts",
endpoint,
]);
AddOutput(ffmpeg, targets);
var command = loopback + " | " + Quote(options.FfmpegPath) + " " + string.Join(" ", ffmpeg.Select(Quote));
return new RavenMuxCommand(command, endpoint, stdoutLog, stderrLog);
return new RavenMuxCommand(command, targets, stdoutLog, stderrLog);
}
private static IReadOnlyList<RavenMuxTarget> BuildTargets(RavenDaemonOptions options)
{
var targets = new List<RavenMuxTarget>
{
new("mimir", Endpoint(options.Transport, options.TargetHost, options.Port, options.SrtMode)),
};
if (options.EnableObsTarget && options.Transport == "srt")
{
targets.Add(new("obs", Endpoint(options.Transport, options.ObsTargetHost, options.ObsPort, options.SrtMode)));
}
return targets;
}
private static string Endpoint(string transport, string host, int port, string srtMode) =>
transport == "tcp-listener"
? $"tcp://{host}:{port}?listen=1"
: $"srt://{host}:{port}?mode={srtMode}&latency=120000&timeout=30000000";
private static void AddOutput(List<string> ffmpeg, IReadOnlyList<RavenMuxTarget> targets)
{
if (targets.Count == 1)
{
ffmpeg.AddRange(["-f", "mpegts", targets[0].Endpoint]);
return;
}
var teeTargets = string.Join("|", targets.Select(static target => "[f=mpegts]" + target.Endpoint));
ffmpeg.AddRange(["-f", "tee", teeTargets]);
}
private static string ResolveLoopbackCommand(RavenDaemonOptions options, string repoRoot)
@ -317,7 +353,7 @@ internal sealed class RavenCaptureMuxState : IAsyncDisposable
public MimirRavenCaptureMuxStateDocument Document { get; private set; }
public static async Task<RavenCaptureMuxState> OpenAsync(RavenDaemonOptions options, string commandLine)
public static async Task<RavenCaptureMuxState> OpenAsync(RavenDaemonOptions options, RavenMuxCommand command)
{
var registry = new CultNetDocumentRegistry()
.Register(CultNetDocumentBinding.ForDocument<MimirRavenCaptureMuxStateDocument>())
@ -332,7 +368,7 @@ internal sealed class RavenCaptureMuxState : IAsyncDisposable
},
}).ConfigureAwait(false);
var key = new CultRecordKey(options.DaemonId);
var document = InitialDocument(options, commandLine);
var document = InitialDocument(options, command);
var state = new RavenCaptureMuxState(node, key, document);
await state.PublishAsync(document, CancellationToken.None).ConfigureAwait(false);
return state;
@ -363,13 +399,13 @@ internal sealed class RavenCaptureMuxState : IAsyncDisposable
node.Dispose();
}
private static MimirRavenCaptureMuxStateDocument InitialDocument(RavenDaemonOptions options, string commandLine) =>
private static MimirRavenCaptureMuxStateDocument InitialDocument(RavenDaemonOptions options, RavenMuxCommand command) =>
new(
options.DaemonId,
DateTimeOffset.UtcNow.ToString("O"),
options.HostId,
"starting",
$"{options.Transport}://{options.TargetHost}:{options.Port}",
command.Targets[0].Endpoint,
options.Transport,
"raven-display",
"raven-realtk-loopback",
@ -385,18 +421,36 @@ internal sealed class RavenCaptureMuxState : IAsyncDisposable
null,
"",
"",
commandLine,
[
"display-capture",
"wasapi-render-loopback",
"ffmpeg-mux",
"srt-mpegts",
"cultmesh-eve-status",
],
command.CommandLine,
CapabilitiesFor(command),
[
"Raven daemon supervises the capture process and publishes typed state.",
"FFmpeg owns media capture, mux, encode, and transport.",
]);
],
command.Targets.Select(static target => target.Name + "=" + target.Endpoint).ToArray());
private static string[] CapabilitiesFor(RavenMuxCommand command)
{
var capabilities = new List<string>
{
"display-capture",
"wasapi-render-loopback",
"ffmpeg-mux",
"srt-mpegts",
"cultmesh-eve-status",
};
if (command.Targets.Any(static target => target.Name == "mimir"))
{
capabilities.Add("mimir-srt-sink");
}
if (command.Targets.Any(static target => target.Name == "obs"))
{
capabilities.Add("obs-srt-sink");
}
return capabilities.ToArray();
}
}
internal static class RavenMuxSupervisor
@ -550,6 +604,7 @@ internal sealed class RavenDaemonEveServer(RavenDaemonOptions options, RavenCapt
host = document.HostId,
status = document.Status,
target = document.TargetEndpoint,
targets = document.TargetEndpoints,
video = document.VideoSourceId,
audio = document.AudioSourceId,
ffmpegPid = document.FfmpegPid,
@ -610,7 +665,7 @@ internal sealed class RavenDaemonEveServer(RavenDaemonOptions options, RavenCapt
new("raven-daemon", $"Raven Daemon\n{doc.Status}", "daemon", true, 0.0, -0.36, 0.0, 0.0, 1.0, 0.54, 0.18, statusTone, doc.DaemonId, null, "/health"),
new("raven-display", $"Display\n{doc.Width}x{doc.Height}@{doc.Framerate}", "video", true, -0.34, 0.02, 0.0, 0.0, 1.0, 0.42, 0.18, doc.VideoCapture, doc.DaemonId, null, null),
new("raven-loopback", $"Realtek Loopback\n{doc.AudioChannels}ch {doc.AudioSampleRate}Hz", "audio", true, 0.34, 0.02, 0.0, 0.0, 1.0, 0.42, 0.18, "wasapi-loopback", doc.DaemonId, null, null),
new("raven-target", $"Mux Target\n{doc.TargetEndpoint}", "transport", true, 0.0, 0.38, 0.0, 0.0, 1.0, 0.72, 0.18, doc.Transport, doc.DaemonId, null, null),
new("raven-target", $"Mux Targets\n{doc.TargetEndpoints.Length}", "transport", true, 0.0, 0.38, 0.0, 0.0, 1.0, 0.72, 0.18, doc.Transport, doc.DaemonId, null, null),
],
new MimirEveDashboardSurfaceSnapshot(
"mimir.eve_surface.v1",
@ -620,7 +675,7 @@ internal sealed class RavenDaemonEveServer(RavenDaemonOptions options, RavenCapt
[
Text("raven-status", $"status {doc.Status}\nffmpeg pid {doc.FfmpegPid?.ToString() ?? "none"}\nrestarts {doc.RestartCount}"),
Text("raven-media", $"video {doc.VideoSourceId} {doc.VideoCapture} {doc.Width}x{doc.Height}@{doc.Framerate}\naudio {doc.AudioSourceId} {doc.AudioChannels}ch {doc.AudioSampleRate}Hz"),
Text("raven-target-text", $"target {doc.TargetEndpoint}\nstdout {doc.StdoutLog}\nstderr {doc.StderrLog}"),
Text("raven-target-text", $"targets {string.Join("\n", doc.TargetEndpoints)}\nstdout {doc.StdoutLog}\nstderr {doc.StderrLog}"),
]),
[]));
}

View file

@ -216,7 +216,8 @@ public sealed record MimirRavenCaptureMuxStateDocument(
[property: Key(19)] string StderrLog,
[property: Key(20)] string CommandLine,
[property: Key(21)] string[] Capabilities,
[property: Key(22)] string[] Notes);
[property: Key(22)] string[] Notes,
[property: Key(23)] string[] TargetEndpoints);
[CultDocument("mimir.eve_dashboard_manifest", "mimir.eve_dashboard_manifest.v1")]
[MessagePackObject]