OBS Integration

Segra's recording engine is built on top of Open Broadcaster Software (OBS) using ObsKit.NET, a modern C# wrapper that provides type-safe access to OBS's powerful recording capabilities.

Architecture Overview

Segra uses a layered architecture to interact with OBS:

Segra Application
       ↓
   ObsKit.NET (C# Wrapper)
       ↓
   OBS Studio (libobs)
       ↓
  Hardware Encoders (NVENC/AMF/QSV)

Core Components

Initialization Process

When Segra starts, it initializes OBS through several stages:

_obsContext = Obs.Initialize(config =>
{
    config
        .WithLocale("en-US")
        .WithDataPath("./data/libobs/")
        .WithModulePath("./obs-plugins/64bit/", "./data/obs-plugins/%module%/")
        .WithVideo(v => v.Resolution(1920, 1080).Fps(60))
        .WithAudio(a => a.WithSampleRate(44100).WithSpeakers(SpeakerLayout.Stereo))
        .WithLogging((level, message) => { /* Log processing */ });
});

Recording Pipeline

Scene Composition

Segra creates a layered scene with multiple capture sources:

Game Capture Hooking

Segra uses OBS's game capture plugin to hook directly into games:

GameCaptureSource = new GameCapture("gameplay", GameCapture.CaptureMode.SpecificWindow);
GameCaptureSource.SetWindow($"*:*:{fileName}");

// Subscribe to hook events
GameCaptureSource.Hooked += OnGameCaptureHookedEvent;
GameCaptureSource.Unhooked += OnGameCaptureUnhookedEvent;

Coexisting with OBS Studio

Only one application can hold a game's capture hook at a time. Segra avoids fighting OBS Studio or Streamlabs for it:

• At recording start, Segra skips Game Capture and uses Window or Display Capture when either of these is true:
  • OBS Studio (obs64) is running and is streaming or recording. Segra checks the newest session log in %APPDATA%\obs-studio\logs\ for the ==== Streaming Start ==== and ==== Recording Start ==== markers.
  • Another application already holds the game's hook (for example OBS Studio's preview or Streamlabs). Segra detects this through the CaptureHook_Pipe<pid> named pipe.
• When you tab back into the recorded game, Segra waits 2 seconds and then:
  • Releases its game capture and switches to Window or Display Capture if OBS Studio is now streaming or recording.
  • Retries Game Capture if OBS Studio isn't active and the hook is free. If the retry times out, Segra tries again on the next tab-in.

Audio Routing

Segra supports three audio output modes:

When game capture hooks successfully, Segra automatically:

• Mutes desktop audio sources
• Unmutes game audio and Discord sources (if enabled)
• Switches back to desktop audio when the game unhooks

Encoder Configuration

Segra configures encoders based on user settings:

videoEncoderSettings.Set("rate_control", "CBR");
videoEncoderSettings.Set("bitrate", targetBitrateKbps);
videoEncoderSettings.Set("max_bitrate", targetBitrateKbps);

videoEncoderSettings.Set("rate_control", "VBR");
videoEncoderSettings.Set("bitrate", minBitrateKbps);
videoEncoderSettings.Set("max_bitrate", maxBitrateKbps);

videoEncoderSettings.Set("rate_control", "CQP");
videoEncoderSettings.Set("cqp", cqLevel);
videoEncoderSettings.Set("qp", cqLevel);

Recording Modes

Segra supports three recording modes, each using different OBS output types:

Session Recording

Uses RecordingOutput to record the entire gaming session to an MP4 file. Segra always attempts the Hybrid MP4 muxer (crash-resilient, chapter markers; OBS 30.2+) and transparently falls back to the plain ffmpeg muxer when the running OBS build doesn't register mp4_output:

_output = new RecordingOutput("simple_output", videoOutputPath);
try
{
    _output.SetFormat(RecordingFormat.HybridMp4);
}
catch (NotSupportedException)
{
    // OBS build didn't register mp4_output; the output is already
    // a working ffmpeg_muxer recorder, no further fallback needed.
}
_output.WithVideoEncoder(_videoEncoder);
_output.WithAudioEncoder(_audioEncoder, track: 0);
_output.Stopped += OnOutputStopped;
_output.Start();

Replay Buffer

Uses ReplayBuffer to maintain a rolling buffer in memory:

_bufferOutput = new ReplayBuffer(
    "replay_buffer_output",
    Settings.Instance.ReplayBufferDuration,
    Settings.Instance.ReplayBufferMaxSize
);
_bufferOutput.SetDirectory(bufferDir);

// Handle replay saved and unexpected stops via .NET events
_bufferOutput.Saved += OnReplaySaved;      // e.Path is populated on the callback
_bufferOutput.Stopped += OnOutputStopped;  // e.Code is an ObsOutputStopCode

_bufferOutput.Start();

// Save the buffer when user presses hotkey
_bufferOutput.Save();

Saves for network / slow storage back-stop on an internal timeout of up to 15 minutes so a stalled mux doesn't leave the replay buffer permanently in a half-saved state.

Hybrid Mode

Runs both session recording and replay buffer simultaneously, allowing:

• Full session recording with bookmarks
• Instant replay saving during gameplay
• Separate file organization

Separate Audio Tracks

Segra records multiple audio tracks using OBS's multi-track support. The upper bound is probed from the loaded OBS build at startup (ObsAudioTrackLimit.Probe()):

// Assign source to multiple tracks
uint mixersMask = (1u << 0) | (1u << (trackIndex + 1));
allAudioSources[i].AudioMixers = mixersMask;

// Create encoder for each track
for (int t = 0; t < trackCount; t++)
{
    var audioEncoder = AudioEncoder.CreateAac(encoderName, 128, t);
    _audioEncoders.Add(audioEncoder);
}

Display and Window Capture

Segra layers three video sources into every scene:

Segra polls once per second while a fallback is in effect and swaps between Window and Display capture as the window's captureability changes.

// Display fallback (bottom layer)
_displaySource = MonitorCapture.FromMonitor(monitorIndex, "display");

// Window fallback (middle layer, WGC)
_windowSource = WindowCapture.FromWindow(windowSpec, "window");

// Game capture (top layer, primary)
_gameCaptureSource = new GameCapture("gameplay", GameCapture.CaptureMode.SpecificWindow);

Resource Management

Segra follows strict resource disposal patterns to prevent memory leaks:

Log Processing

OBS log messages are processed asynchronously using channels to prevent blocking:

private static readonly Channel<(int level, string message)> _logChannel =
    Channel.CreateUnbounded<(int, string)>(new UnboundedChannelOptions
    {
        SingleReader = true,
        SingleWriter = false
    });

// OBS logging callback (non-blocking)
.WithLogging((level, message) =>
{
    _logChannel.Writer.TryWrite(((int)level, message));
})

// Background processing
await foreach (var (level, formattedMessage) in _logChannel.Reader.ReadAllAsync())
{
    Log.Information($"{(ObsLogLevel)level}: {formattedMessage}");
}

This prevents OBS's internal logging thread from being blocked by Serilog's file I/O operations.

Related Resources