Clip Service

The ClipService handles creating clips from recorded sessions and replay buffers. It uses FFmpeg to extract segments, apply encoding settings, and concatenate multiple selections into a single output file.

Overview

Implemented in Backend/Media/ClipService.cs, the service provides:

• Extract multiple segments from different source videos
• Concatenate segments into a single clip
• Re-encode with configurable quality settings
• Hardware and software encoding support
• Progress tracking and cancellation
• Automatic metadata generation

Core Methods

CreateClips

Creates a clip from one or more video segments.

public static async Task CreateClips(List<Segment> segments, bool createSeparateClips = false)

Process Flow:

1. Validates selections and calculates total duration
2. Extracts each segment to a temporary file
3. Concatenates temporary files (if multiple selections)
4. Generates metadata, thumbnail, and waveform
5. Adds clip to content library
6. Cleans up temporary files

Progress Events:

Sends ClipProgress messages to the frontend with:

• id: Unique clip operation ID
• progress: Progress percentage (0-100, or -1 for error)
• segments: The original segments list
• error: Error message (only when progress = -1)

var segments = new List<Segment>
{
    new Segment
    {
        Id = 1,
        Game = "Valorant",
        FileName = "2026-03-03_14-30-00",
        Type = "Session",
        StartTime = 45.5,
        EndTime = 78.2,
        Title = "Ace Round"
    }
};

await ClipService.CreateClips(segments);

var segments = new List<Segment>
{
    new Segment
    {
        Id = 1,
        Game = "Valorant",
        FileName = "2026-03-03_14-30-00",
        Type = "Session",
        StartTime = 45.5,
        EndTime = 78.2
    },
    new Segment
    {
        Id = 2,
        Game = "Valorant",
        FileName = "2026-03-03_15-00-00",
        Type = "Buffer",
        StartTime = 10.0,
        EndTime = 25.0
    }
};

await ClipService.CreateClips(segments);

CancelClip

Cancels an in-progress clip operation.

public static async void CancelClip(int clipId)

Behavior:

• Kills all active FFmpeg processes associated with the clip ID
• Removes processes from tracking
• Sends completion message to frontend
• Cleanup of temporary files is handled by the original CreateClips task

// From frontend message handler
int clipId = 123456789;
ClipService.CancelClip(clipId);

Encoding Configuration

The service uses settings from Settings.Instance to configure encoding:

Encoder Selection

Codec Selection

Hardware Encoder Settings

NVIDIA (NVENC):

FFmpeg arguments: -cq {quality} -preset {preset}

AMD (AMF):

FFmpeg arguments: -rc cqp -qp_i {quality} -qp_p {quality} -usage {preset}

Intel (QuickSync):

FFmpeg arguments: -global_quality {quality} -preset {preset}

Software Encoder Settings

FFmpeg arguments: -crf {quality} -preset {preset}

Additional Settings

Codec Matrix

The service automatically selects the appropriate codec based on encoder and codec settings:

Hardware-Accelerated Decoding

Clip extraction runs the source recording through a hardware-accelerated decode path whenever possible. ClipService.BuildHwDecodeArgs picks the flags based on the source codec (detected via FFmpegService.DetectVideoCodec) and the detected GPU vendor:

If the hardware decode run fails and the clip wasn't cancelled, Segra automatically retries the same segment with software decoding. This mainly speeds up clip creation from AV1 recordings on supported GPUs.

FFmpeg Command Examples

Single Clip Extraction

ffmpeg -y -hwaccel auto -ss 45.5 -t 32.7 \
  -i "input.mp4" \
  -c:v h264_nvenc -preset p4 -cq 20 -r 60 \
  -c:a aac -b:a 192k \
  -movflags +faststart \
  "output.mp4"

Multi-Clip Concatenation

ffmpeg -y -f concat -safe 0 \
  -i "concat_list.txt" \
  -c copy \
  -movflags +faststart \
  "output.mp4"

Where concat_list.txt contains (paths are written with forward slashes by FFmpegService.BuildConcatListLine):

file 'C:/Temp/clip123.mp4'
file 'C:/Temp/clip456.mp4'

File Organization

Clips are saved to:

ContentFolder/Clips/{GameName}/{Timestamp}.mp4

Example:

C:/Users/User/Videos/Segra/Clips/Valorant/2026-03-03_14-45-30.mp4

Each clip includes:

• Video file: {timestamp}.mp4
• Metadata: {contentId}.json (game, title, timestamps, IGDB ID, compressed flag)
• Thumbnail: {contentId}.jpeg
• Waveform: {contentId}.peaks.json

Progress Tracking

The service tracks progress at multiple stages:

Progress is weighted by clip duration:

double currentProgress = (processedDuration + (progress * clipDuration)) / totalDuration * 95;

Error Handling

The service includes comprehensive error handling:

Validation Errors

• Empty selections list
• Zero or negative total duration
• FFmpeg not found
• Missing source files

Extraction Errors

• Failed to create temp clip file
• FFmpeg process errors
• Cancellation during extraction

Concatenation Errors

• Failed to create output file
• File not ready for metadata generation

Cleanup

All temporary files are cleaned up in the finally block:

• Individual clip segments
• Concat list file
• Partial output files (on error)

Thread Safety

The service uses a ProcessLock object to ensure thread-safe access to the active FFmpeg process dictionary:

lock (ProcessLock)
{
    ActiveFFmpegProcesses[clipId] = process;
}

This prevents race conditions when:

• Adding processes during extraction
• Removing processes after completion
• Cancelling clips from frontend

Integration Points

• FFmpegService: Executes FFmpeg with progress callbacks
• ContentService: Generates thumbnails, metadata, and waveforms
• SettingsService: Loads clips into content library
• StorageService: Sanitizes game names for folder organization
• MessageService: Sends progress updates to frontend