DreamineVMS.Services.Streaming.FfmpegHlsStreamService에 대한 상속 다이어그램 :

[범례]

DreamineVMS.Services.Streaming.FfmpegHlsStreamService에 대한 협력 다이어그램:

[범례]

Public 멤버 함수
	FfmpegHlsStreamService (ILogger< FfmpegHlsStreamService > logger, IVmsCameraRepository repository, ICameraRuntimeStateService runtimeState, IOptions< FfmpegOptions > options)
override async Task	StopAsync (CancellationToken cancellationToken)
override void	Dispose ()
async Task	StartAllAsync (CancellationToken cancellationToken=default)
async Task	StopAllAsync (CancellationToken cancellationToken=default)
async Task	StartAsync (string cameraId, CancellationToken cancellationToken=default)
async Task	StopAsync (string cameraId, CancellationToken cancellationToken=default)

Protected 멤버 함수
override async Task	ExecuteAsync (CancellationToken stoppingToken)

Private 멤버 함수
async Task	StartInternalAsync (string cameraId, CancellationToken cancellationToken)
async Task	StopInternalAsync (string cameraId, CancellationToken cancellationToken)
async Task	WatchdogAsync (CancellationToken cancellationToken)
void	StartProcessUnsafe (CameraDevice camera)
async Task	ShutdownProcessAsync (string cameraId, Process process, CancellationToken cancellationToken)
void	ForceKillProcessUnsafe (string cameraId)
SemaphoreSlim	GetCameraOperationLock (string cameraId)
string	BuildArguments (CameraDevice camera)
void	InitWatchStats (string cameraId)
string	GetOutputRoot ()
string	GetCameraOutputDirectory (string cameraId)
string	GetPlaylistPath (string cameraId)
void	PreparePlaylistForNewSession (string cameraId)
void	CleanupOldSegmentFiles (string cameraId, TimeSpan minimumAge)

정적 Private 멤버 함수
static long DateTime writeTime	ReadSequenceAndWriteTime (string path)
static string	Quote (string value)

Private 속성
readonly ILogger< FfmpegHlsStreamService >	_logger
readonly IVmsCameraRepository	_repository
readonly ICameraRuntimeStateService	_runtimeState
readonly FfmpegOptions	_options
readonly Dictionary< string, Process >	_processes = new()
readonly Dictionary< string, long >	_lastSequences = new()
readonly Dictionary< string, DateTime >	_lastWrites = new()
readonly ConcurrentDictionary< string, SemaphoreSlim >	_cameraOperationLocks = new()
readonly ConcurrentDictionary< string, byte >	_intentionalStops = new()
readonly SemaphoreSlim	_sync = new(1, 1)
readonly? ChildProcessJob	_processJob
bool	_disposed

정적 Private 속성
static readonly Regex	MediaSeqRegex = new(@"#EXT-X-MEDIA-SEQUENCE:(\d+)", RegexOptions.Compiled)
static readonly TimeSpan	GracefulExitTimeout = TimeSpan.FromMilliseconds(800)
static readonly TimeSpan	KillWaitTimeout = TimeSpan.FromSeconds(2)
static long	sequence

상세한 설명

FFmpeg 프로세스를 사용해서 RTSP 스트림을 HLS 스트림으로 변환하는 서비스입니다.

FfmpegHlsStreamService.cs 파일의 23 번째 라인에서 정의되었습니다.

생성자 & 소멸자 문서화

◆ FfmpegHlsStreamService()

DreamineVMS.Services.Streaming.FfmpegHlsStreamService.FfmpegHlsStreamService	(	ILogger< FfmpegHlsStreamService >	logger,
		IVmsCameraRepository	repository,
		ICameraRuntimeStateService	runtimeState,
		IOptions< FfmpegOptions >	options )

inline

FfmpegHlsStreamService 클래스의 새 인스턴스를 초기화합니다.

매개변수

logger	로거입니다.
repository	카메라 저장소입니다.
runtimeState	카메라 런타임 상태 서비스입니다.
options	FFmpeg 옵션입니다.

예외

ArgumentNullException 필수 입력 인자 중 하나가 null인 경우 발생합니다.

FfmpegHlsStreamService.cs 파일의 217 번째 라인에서 정의되었습니다.

    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
    }

다음을 참조함 : _logger, _options, _repository, _runtimeState.

멤버 함수 문서화

◆ BuildArguments()

string DreamineVMS.Services.Streaming.FfmpegHlsStreamService.BuildArguments ( CameraDevice camera )

inlineprivate

Arguments 값을 구성합니다.

매개변수

camera camera에 사용할 CameraDevice 값입니다.

반환값: Build Arguments 작업에서 생성한 string 결과입니다.

FfmpegHlsStreamService.cs 파일의 1135 번째 라인에서 정의되었습니다.

    {
        bool isDshow = camera.RtspUrl.StartsWith("dshow://", StringComparison.OrdinalIgnoreCase);
 
        string playlistPath = Quote(GetPlaylistPath(camera.Id));
        string sessionStamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString(System.Globalization.CultureInfo.InvariantCulture);
        string segmentPath = Quote(Path.Combine(GetCameraOutputDirectory(camera.Id), $"seg_{sessionStamp}_%05d.ts"));
        string videoCodec = (_options.VideoCodec ?? "libx264").ToLowerInvariant();
        string audioCodec = (_options.AudioCodec ?? "an").ToLowerInvariant();
        int segmentSeconds = Math.Max(1, _options.HlsSegmentSeconds);
        int listSize = Math.Max(4, _options.HlsListSize);
        int videoFps = Math.Max(1, _options.VideoFps);
        int keyFrameInterval = segmentSeconds * videoFps;
 
        // dshow://video=장치이름 → -f dshow -i "video=장치이름"
        // rtsp://...           → RTSP 전용 플래그 + -i "rtsp://..."
        string inputDevice = isDshow
            ? Quote(camera.RtspUrl["dshow://".Length..])
            : Quote(camera.RtspUrl);
 
        List<string> parts = new() { "-hide_banner", "-loglevel warning" };
 
        if (isDshow)
        {
            parts.Add("-f dshow");
        }
        else
        {
            parts.Add("-rtsp_transport tcp");
            parts.Add("-rtsp_flags prefer_tcp");
            parts.Add("-analyzeduration 2000000");
            parts.Add("-probesize 2000000");
        }
 
        parts.Add("-fflags +genpts+discardcorrupt+nobuffer");
        parts.Add("-flags low_delay");
        parts.Add("-i");
        parts.Add(inputDevice);
        parts.Add("-map 0:v:0");
        parts.Add("-map 0:a?");
        parts.Add("-dn");
        parts.Add("-sn");
 
        if (videoCodec == "copy")
        {
            parts.Add("-c:v copy");
        }
        else
        {
            parts.Add("-c:v libx264");
            parts.Add("-preset ultrafast");
            parts.Add("-tune zerolatency");
            parts.Add("-profile:v baseline");
            parts.Add("-level:v 3.1");
            parts.Add("-pix_fmt yuv420p");
            if (_options.VideoMaxWidth > 0)
            {
                parts.Add($"-vf {Quote($"scale='min({_options.VideoMaxWidth},iw)':-2,fps={videoFps}")}");
            }
            else
            {
                parts.Add($"-r {videoFps}");
            }
            parts.Add($"-b:v {_options.VideoBitrate}");
            parts.Add($"-maxrate {_options.VideoMaxRate}");
            parts.Add($"-bufsize {_options.VideoBufferSize}");
            parts.Add($"-g {keyFrameInterval}");
            parts.Add($"-keyint_min {keyFrameInterval}");
            parts.Add("-sc_threshold 0");
            parts.Add("-bf 0");
            parts.Add($"-force_key_frames {Quote($"expr:gte(t,n_forced*{segmentSeconds})")}");
        }
 
        if (audioCodec == "an")
        {
            parts.Add("-an");
        }
        else
        {
            parts.Add($"-c:a {audioCodec}");
            parts.Add($"-b:a {_options.AudioBitrate}");
            parts.Add($"-ar {_options.AudioRate}");
            parts.Add($"-ac {_options.AudioChannels}");
        }
 
        parts.Add("-muxdelay 0");
        parts.Add("-muxpreload 0");
        parts.Add("-f hls");
        parts.Add("-hls_segment_type mpegts");
        parts.Add("-hls_allow_cache 0");
        parts.Add($"-hls_time {segmentSeconds}");
        parts.Add($"-hls_list_size {listSize}");
        // Windows + WebView2 환경에서는 video 태그가 .ts 파일 핸들을 오래 잡는 경우가 있습니다.
        // delete_segments를 사용하면 ffmpeg가 WebView2가 읽는 세그먼트를 삭제하려다
        // Permission denied가 발생하고 playlist/segment 수명이 꼬일 수 있습니다.
        // 실행 중 삭제는 하지 않고, 세션별 고유 파일명 + 지연 정리 방식으로 안정화합니다.
        parts.Add("-hls_flags omit_endlist+independent_segments+temp_file");
        parts.Add($"-hls_segment_filename {segmentPath}");
        parts.Add(playlistPath);
 
        return string.Join(' ', parts);
    }

다음을 참조함 : _options, GetCameraOutputDirectory(), GetPlaylistPath(), DreamineVMS.Models.CameraDevice.Id, Quote(), DreamineVMS.Models.CameraDevice.RtspUrl.

다음에 의해서 참조됨 : StartProcessUnsafe().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ CleanupOldSegmentFiles()

void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.CleanupOldSegmentFiles	(	string	cameraId,
		TimeSpan	minimumAge )

inlineprivate

Cleanup Old Segment Files 작업을 수행합니다.

매개변수

cameraId	camera Id에 사용할 `string` 값입니다.
minimumAge	minimum Age에 사용할 `TimeSpan` 값입니다.

FfmpegHlsStreamService.cs 파일의 1458 번째 라인에서 정의되었습니다.

    {
        string directory = GetCameraOutputDirectory(cameraId);
        if (!Directory.Exists(directory))
        {
            return;
        }
 
        DateTime thresholdUtc = DateTime.UtcNow - minimumAge;
 
        foreach (string file in Directory.EnumerateFiles(directory, "seg_*.ts"))
        {
            try
            {
                if (File.GetLastWriteTimeUtc(file) > thresholdUtc)
                {
                    continue;
                }
 
                File.Delete(file);
            }
            catch (IOException)
            {
                // WebView2/Chrome이 읽는 중인 세그먼트는 다음 정리 주기에 다시 시도합니다.
            }
            catch (UnauthorizedAccessException)
            {
                // 파일 핸들 또는 백신/인덱서 점유 가능성이 있으므로 무시합니다.
            }
        }
    }

다음을 참조함 : GetCameraOutputDirectory().

다음에 의해서 참조됨 : StartInternalAsync(), StartProcessUnsafe(), StopInternalAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ Dispose()

override void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.Dispose ( )

inline

서비스 Dispose 시 남은 ffmpeg 프로세스와 Job Object를 정리합니다.

FfmpegHlsStreamService.cs 파일의 329 번째 라인에서 정의되었습니다.

    {
        if (_disposed)
        {
            base.Dispose();
            return;
        }
 
        _disposed = true;
 
        bool acquired = false;
        try
        {
            acquired = _sync.Wait(TimeSpan.FromSeconds(2));
 
            foreach (string cameraId in _processes.Keys.ToArray())
            {
                _intentionalStops.TryAdd(cameraId, 0);
                ForceKillProcessUnsafe(cameraId);
            }
        }
        catch
        {
            // 정리 단계의 예외는 무시합니다.
        }
        finally
        {
            if (acquired)
            {
                _sync.Release();
            }
        }
 
        foreach (SemaphoreSlim cameraLock in _cameraOperationLocks.Values)
        {
            try { cameraLock.Dispose(); } catch { }
        }
        _cameraOperationLocks.Clear();
 
        _processJob?.Dispose();
        _sync.Dispose();
 
        base.Dispose();
    }

다음을 참조함 : _cameraOperationLocks, _disposed, _intentionalStops, _processes, _processJob, _sync, ForceKillProcessUnsafe().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

◆ ExecuteAsync()

override async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.ExecuteAsync ( CancellationToken stoppingToken )

inlineprotected

Execute Async 작업을 수행합니다.

매개변수

stoppingToken stopping Token에 사용할 CancellationToken 값입니다.

반환값: Execute Async 작업에서 생성한 Task 결과입니다.

FfmpegHlsStreamService.cs 파일의 253 번째 라인에서 정의되었습니다.

    {
        Directory.CreateDirectory(GetOutputRoot());
 
        if (_options.StartOnApplicationStartup)
        {
            await StartAllAsync(stoppingToken);
        }
 
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await WatchdogAsync(stoppingToken);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "WatchdogAsync 오류 발생 — 서비스 계속 실행.");
            }
 
            try
            {
                await Task.Delay(
                    TimeSpan.FromSeconds(Math.Max(1, _options.WatchdogIntervalSeconds)),
                    stoppingToken);
            }
            catch (OperationCanceledException)
            {
                break;
            }
        }
    }

다음을 참조함 : _logger, _options, GetOutputRoot(), StartAllAsync(), WatchdogAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

◆ ForceKillProcessUnsafe()

void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.ForceKillProcessUnsafe ( string cameraId )

inlineprivate

Dispose 등 비동기 호출이 불가능한 시점에 사용하는 동기 강제 종료입니다.

매개변수

cameraId 카메라 ID입니다.

FfmpegHlsStreamService.cs 파일의 1055 번째 라인에서 정의되었습니다.

    {
        if (!_processes.TryGetValue(cameraId, out Process? process))
        {
            return;
        }
 
        try
        {
            if (!process.HasExited)
            {
                process.Kill(entireProcessTree: true);
                process.WaitForExit(1000);
            }
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Failed to force-kill FFmpeg process for {CameraId}.", cameraId);
        }
        finally
        {
            try { process.Dispose(); } catch { /* ignore */ }
            _processes.Remove(cameraId);
        }
    }

다음을 참조함 : _logger, _processes.

다음에 의해서 참조됨 : Dispose().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ GetCameraOperationLock()

SemaphoreSlim DreamineVMS.Services.Streaming.FfmpegHlsStreamService.GetCameraOperationLock ( string cameraId )

inlineprivate

Camera Operation Lock 값을 가져옵니다.

매개변수

cameraId camera Id에 사용할 string 값입니다.

반환값: Get Camera Operation Lock 작업에서 생성한 SemaphoreSlim 결과입니다.

FfmpegHlsStreamService.cs 파일의 1106 번째 라인에서 정의되었습니다.

    {
        return _cameraOperationLocks.GetOrAdd(cameraId, _ => new SemaphoreSlim(1, 1));
    }

다음을 참조함 : _cameraOperationLocks.

다음에 의해서 참조됨 : StartAsync(), StopAsync().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ GetCameraOutputDirectory()

string DreamineVMS.Services.Streaming.FfmpegHlsStreamService.GetCameraOutputDirectory ( string cameraId )

inlineprivate

Camera Output Directory 값을 가져옵니다.

매개변수

cameraId camera Id에 사용할 string 값입니다.

반환값: Get Camera Output Directory 작업에서 생성한 string 결과입니다.

FfmpegHlsStreamService.cs 파일의 1357 번째 라인에서 정의되었습니다.

    {
        return Path.Combine(GetOutputRoot(), cameraId);
    }

다음을 참조함 : GetOutputRoot().

다음에 의해서 참조됨 : BuildArguments(), CleanupOldSegmentFiles(), GetPlaylistPath(), PreparePlaylistForNewSession(), StartProcessUnsafe().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ GetOutputRoot()

string DreamineVMS.Services.Streaming.FfmpegHlsStreamService.GetOutputRoot ( )

inlineprivate

Output Root 값을 가져옵니다.

반환값: Get Output Root 작업에서 생성한 string 결과입니다.

FfmpegHlsStreamService.cs 파일의 1326 번째 라인에서 정의되었습니다.

    {
        return Path.IsPathRooted(_options.OutputRoot)
            ? _options.OutputRoot
            : Path.Combine(AppContext.BaseDirectory, _options.OutputRoot);
    }

다음을 참조함 : _options.

다음에 의해서 참조됨 : ExecuteAsync(), GetCameraOutputDirectory().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ GetPlaylistPath()

string DreamineVMS.Services.Streaming.FfmpegHlsStreamService.GetPlaylistPath ( string cameraId )

inlineprivate

Playlist Path 값을 가져옵니다.

매개변수

cameraId camera Id에 사용할 string 값입니다.

반환값: Get Playlist Path 작업에서 생성한 string 결과입니다.

FfmpegHlsStreamService.cs 파일의 1386 번째 라인에서 정의되었습니다.

    {
        return Path.Combine(GetCameraOutputDirectory(cameraId), "index.m3u8");
    }

다음을 참조함 : GetCameraOutputDirectory().

다음에 의해서 참조됨 : BuildArguments(), InitWatchStats(), PreparePlaylistForNewSession(), WatchdogAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ InitWatchStats()

void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.InitWatchStats ( string cameraId )

inlineprivate

Init Watch Stats 작업을 수행합니다.

매개변수

cameraId camera Id에 사용할 string 값입니다.

FfmpegHlsStreamService.cs 파일의 1254 번째 라인에서 정의되었습니다.

    {
        string path = GetPlaylistPath(cameraId);
        if (File.Exists(path))
        {
            (long sequence, DateTime writeTime) = ReadSequenceAndWriteTime(path);
            _lastSequences[cameraId] = sequence;
            _lastWrites[cameraId] = writeTime;
        }
        else
        {
            _lastSequences[cameraId] = -1;
            _lastWrites[cameraId] = DateTime.UtcNow;
        }
    }

다음을 참조함 : _lastSequences, _lastWrites, GetPlaylistPath(), ReadSequenceAndWriteTime(), sequence.

다음에 의해서 참조됨 : StartProcessUnsafe().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ PreparePlaylistForNewSession()

void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.PreparePlaylistForNewSession ( string cameraId )

inlineprivate

Prepare Playlist For New Session 작업을 수행합니다.

매개변수

cameraId camera Id에 사용할 string 값입니다.

FfmpegHlsStreamService.cs 파일의 1407 번째 라인에서 정의되었습니다.

    {
        string directory = GetCameraOutputDirectory(cameraId);
        Directory.CreateDirectory(directory);
 
        string playlistPath = GetPlaylistPath(cameraId);
        string preparingPlaylist = string.Join(Environment.NewLine,
            "#EXTM3U",
            "#EXT-X-VERSION:3",
            "#EXT-X-TARGETDURATION:1",
            "#EXT-X-MEDIA-SEQUENCE:0",
            string.Empty);
 
        try
        {
            File.WriteAllText(playlistPath, preparingPlaylist);
        }
        catch (IOException ex)
        {
            _logger.LogDebug(ex, "Playlist reset skipped because the file is currently locked: {CameraId}.", cameraId);
        }
        catch (UnauthorizedAccessException ex)
        {
            _logger.LogDebug(ex, "Playlist reset skipped because access was denied: {CameraId}.", cameraId);
        }
    }

다음을 참조함 : _logger, GetCameraOutputDirectory(), GetPlaylistPath().

다음에 의해서 참조됨 : StartProcessUnsafe().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ Quote()

string DreamineVMS.Services.Streaming.FfmpegHlsStreamService.Quote ( string value )

inlinestaticprivate

Quote 작업을 수행합니다.

매개변수

value 적용할 값입니다.

반환값: Quote 작업에서 생성한 string 결과입니다.

FfmpegHlsStreamService.cs 파일의 1514 번째 라인에서 정의되었습니다.

    {
        return $"\"{value}\"";
    }

다음에 의해서 참조됨 : BuildArguments().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ ReadSequenceAndWriteTime()

long DateTime writeTime DreamineVMS.Services.Streaming.FfmpegHlsStreamService.ReadSequenceAndWriteTime ( string path )

inlinestaticprivate

FfmpegHlsStreamService.cs 파일의 1294 번째 라인에서 정의되었습니다.

    {
        DateTime writeTime = File.GetLastWriteTimeUtc(path);
        try
        {
            string text = File.ReadAllText(path);
            Match match = MediaSeqRegex.Match(text);
            long sequence = match.Success && long.TryParse(match.Groups[1].Value, out long value) ? value : -1;
            return (sequence, writeTime);
        }
        catch
        {
            return (-1, writeTime);
        }
    }

다음을 참조함 : MediaSeqRegex, sequence.

다음에 의해서 참조됨 : InitWatchStats(), WatchdogAsync().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ ShutdownProcessAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.ShutdownProcessAsync	(	string	cameraId,
		Process	process,
		CancellationToken	cancellationToken )

inlineprivate

ffmpeg 프로세스를 graceful → kill 순서로 비동기 종료합니다.

매개변수

cameraId	카메라 ID입니다.
process	종료할 프로세스입니다.
cancellationToken	취소 토큰입니다.

반환값: 비동기 작업입니다.

FfmpegHlsStreamService.cs 파일의 970 번째 라인에서 정의되었습니다.

    {
        try
        {
            if (process.HasExited)
            {
                return;
            }
 
            // 1) stdin에 'q'를 보내 ffmpeg가 깨끗하게 종료할 기회를 줍니다.
            //    파일이 깨지지 않게 마지막 세그먼트를 flush하고 빠져나옵니다.
            bool gracefulOk = false;
            try
            {
                if (process.StartInfo.RedirectStandardInput && !process.HasExited)
                {
                    await process.StandardInput.WriteAsync('q');
                    await process.StandardInput.FlushAsync(cancellationToken);
                    process.StandardInput.Close();
                }
 
                using CancellationTokenSource gracefulCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                gracefulCts.CancelAfter(GracefulExitTimeout);
 
                try
                {
                    await process.WaitForExitAsync(gracefulCts.Token);
                    gracefulOk = true;
                }
                catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
                {
                    // graceful timeout — Kill로 폴백.
                }
            }
            catch (Exception ex)
            {
                _logger.LogDebug(ex, "Graceful stop attempt failed for {CameraId}.", cameraId);
            }
 
            // 2) 아직 살아있으면 강제 종료.
            if (!gracefulOk && !process.HasExited)
            {
                try
                {
                    process.Kill(entireProcessTree: true);
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Kill failed for {CameraId}.", cameraId);
                }
 
                try
                {
                    using CancellationTokenSource killCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                    killCts.CancelAfter(KillWaitTimeout);
                    await process.WaitForExitAsync(killCts.Token);
                }
                catch (OperationCanceledException)
                {
                    _logger.LogWarning("FFmpeg did not exit within timeout for {CameraId}.", cameraId);
                }
            }
        }
        finally
        {
            try { process.Dispose(); } catch { /* ignore */ }
        }
    }

다음을 참조함 : _logger, GracefulExitTimeout, KillWaitTimeout.

다음에 의해서 참조됨 : StartInternalAsync(), StopInternalAsync(), WatchdogAsync().

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StartAllAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StartAllAsync ( CancellationToken cancellationToken = default )

inline

Start All Async 작업을 수행합니다.

매개변수

cancellationToken 취소 요청을 감시하는 토큰입니다.

반환값: Start All Async 작업에서 생성한 Task 결과입니다.

DreamineVMS.Services.Streaming.ICameraStreamService를 구현.

FfmpegHlsStreamService.cs 파일의 398 번째 라인에서 정의되었습니다.

    {
        // 직렬로 시작합니다. 시작 자체는 빠르고, FFmpeg 동시 spawn으로 인한
        // 초기 burst를 줄이는 효과가 있습니다.
        foreach (CameraDevice camera in _repository.GetAll().Where(camera => camera.Enabled && !camera.IsDirectHls))
        {
            await StartAsync(camera.Id, cancellationToken);
        }
    }

다음을 참조함 : _repository, DreamineVMS.Models.CameraDevice.Enabled, DreamineVMS.Models.CameraDevice.Id, DreamineVMS.Models.CameraDevice.IsDirectHls, StartAsync().

다음에 의해서 참조됨 : ExecuteAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StartAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StartAsync	(	string	cameraId,
		CancellationToken	cancellationToken = default )

inline

Start Async 작업을 수행합니다.

매개변수

cameraId	camera Id에 사용할 `string` 값입니다.
cancellationToken	취소 요청을 감시하는 토큰입니다.

반환값: Start Async 작업에서 생성한 Task 결과입니다.

DreamineVMS.Services.Streaming.ICameraStreamService를 구현.

FfmpegHlsStreamService.cs 파일의 476 번째 라인에서 정의되었습니다.

    {
        SemaphoreSlim cameraLock = GetCameraOperationLock(cameraId);
        await cameraLock.WaitAsync(cancellationToken);
        try
        {
            await StartInternalAsync(cameraId, cancellationToken);
        }
        finally
        {
            cameraLock.Release();
        }
    }

다음을 참조함 : GetCameraOperationLock(), StartInternalAsync().

다음에 의해서 참조됨 : StartAllAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StartInternalAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StartInternalAsync	(	string	cameraId,
		CancellationToken	cancellationToken )

inlineprivate

Start Internal Async 작업을 수행합니다.

매개변수

cameraId	camera Id에 사용할 `string` 값입니다.
cancellationToken	취소 요청을 감시하는 토큰입니다.

반환값: Start Internal Async 작업에서 생성한 Task 결과입니다.

예외

InvalidOperationException 현재 객체 상태에서 Start Internal Async 작업을 수행할 수 없는 경우 발생합니다.

FfmpegHlsStreamService.cs 파일의 576 번째 라인에서 정의되었습니다.

    {
        CameraDevice? camera = _repository.GetAll().FirstOrDefault(item => item.Id == cameraId);
        if (camera is null)
        {
            throw new InvalidOperationException($"Camera '{cameraId}' was not found.");
        }
 
        // StartAll 직전 StopAll이 눌렸거나 빠르게 Stop→Start가 반복되는 경우를 위해
        // 같은 카메라의 Stop/Start는 cameraOperationLock으로 직렬화합니다.
        Process? toStop = null;
        await _sync.WaitAsync(cancellationToken);
        try
        {
            if (_processes.TryGetValue(camera.Id, out Process? existing))
            {
                if (!existing.HasExited)
                {
                    _intentionalStops.TryAdd(camera.Id, 0);
                    _processes.Remove(camera.Id);
                    toStop = existing;
                }
                else
                {
                    _processes.Remove(camera.Id);
                    try { existing.Dispose(); } catch { }
                }
            }
        }
        finally
        {
            _sync.Release();
        }
 
        if (toStop is not null)
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Disconnected, $"Restarting camera: {camera.Name}");
            await Task.Delay(TimeSpan.FromMilliseconds(700), cancellationToken);
            await ShutdownProcessAsync(camera.Id, toStop, cancellationToken);
            CleanupOldSegmentFiles(camera.Id, TimeSpan.FromMinutes(30));
        }
 
        await _sync.WaitAsync(cancellationToken);
        try
        {
            _intentionalStops.TryRemove(camera.Id, out _);
            _lastSequences.Remove(camera.Id);
            _lastWrites.Remove(camera.Id);
            StartProcessUnsafe(camera);
        }
        finally
        {
            _sync.Release();
        }
    }

다음을 참조함 : _intentionalStops, _lastSequences, _lastWrites, _processes, _repository, _runtimeState, _sync, CleanupOldSegmentFiles(), DreamineVMS.Models.CameraDevice.Id, ShutdownProcessAsync(), StartProcessUnsafe().

다음에 의해서 참조됨 : StartAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StartProcessUnsafe()

void DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StartProcessUnsafe ( CameraDevice camera )

inlineprivate

Start Process Unsafe 작업을 수행합니다.

매개변수

camera camera에 사용할 CameraDevice 값입니다.

FfmpegHlsStreamService.cs 파일의 850 번째 라인에서 정의되었습니다.

    {
        if (camera.IsDirectHls)
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Connected, $"Direct HLS: {camera.Name}");
            return;
        }
 
        if (string.IsNullOrWhiteSpace(camera.RtspUrl) || camera.RtspUrl.Contains("CHANGE_ME", StringComparison.OrdinalIgnoreCase))
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Faulted, $"RTSP URL is not configured: {camera.Name}");
            return;
        }
 
        if (!File.Exists(_options.Path))
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Faulted, $"ffmpeg.exe was not found: {_options.Path}");
            return;
        }
 
        Directory.CreateDirectory(GetCameraOutputDirectory(camera.Id));
        PreparePlaylistForNewSession(camera.Id);
        CleanupOldSegmentFiles(camera.Id, TimeSpan.FromMinutes(30));
 
        string arguments = BuildArguments(camera);
        ProcessStartInfo startInfo = new()
        {
            FileName = _options.Path,
            Arguments = arguments,
            UseShellExecute = false,
            CreateNoWindow = true,
            RedirectStandardError = true,
            RedirectStandardOutput = true,
            RedirectStandardInput = true   // graceful 'q' 종료를 위해 추가
        };
 
        Process process = new() { StartInfo = startInfo, EnableRaisingEvents = true };
        process.Exited += (_, _) =>
        {
            // 의도된 정지(StopAsync / Restart)에 의한 종료는 Faulted로 표시하지 않습니다.
            if (_intentionalStops.ContainsKey(camera.Id))
            {
                return;
            }
 
            _runtimeState.SetState(camera.Id, CameraConnectionState.Faulted, $"FFmpeg exited: {camera.Name}");
        };
 
        process.ErrorDataReceived += (_, args) =>
        {
            if (string.IsNullOrWhiteSpace(args.Data))
            {
                return;
            }
 
            _logger.LogWarning("[ffmpeg:{CameraId}] {Line}", camera.Id, args.Data);
        };
        process.OutputDataReceived += (_, _) => { /* stdout은 사용하지 않습니다. */ };
 
        try
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Connecting, $"Starting HLS: {camera.Name}");
            process.Start();
 
            _processJob?.AddProcess(process);
 
            process.BeginErrorReadLine();
            process.BeginOutputReadLine();
            _processes[camera.Id] = process;
            InitWatchStats(camera.Id);
            _logger.LogInformation("Started FFmpeg HLS for camera {CameraId}.", camera.Id);
        }
        catch (Exception ex)
        {
            _runtimeState.SetState(camera.Id, CameraConnectionState.Faulted, $"Failed to start FFmpeg: {camera.Name}", ex.Message);
            _logger.LogError(ex, "Failed to start FFmpeg for camera {CameraId}.", camera.Id);
            process.Dispose();
        }
    }

다음을 참조함 : _intentionalStops, _logger, _options, _processes, _processJob, _runtimeState, BuildArguments(), CleanupOldSegmentFiles(), GetCameraOutputDirectory(), DreamineVMS.Models.CameraDevice.Id, InitWatchStats(), DreamineVMS.Models.CameraDevice.IsDirectHls, PreparePlaylistForNewSession(), DreamineVMS.Models.CameraDevice.RtspUrl.

다음에 의해서 참조됨 : StartInternalAsync(), WatchdogAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StopAllAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StopAllAsync ( CancellationToken cancellationToken = default )

inline

Stop All Async 작업을 수행합니다.

매개변수

cancellationToken 취소 요청을 감시하는 토큰입니다.

반환값: Stop All Async 작업에서 생성한 Task 결과입니다.

DreamineVMS.Services.Streaming.ICameraStreamService를 구현.

FfmpegHlsStreamService.cs 파일의 432 번째 라인에서 정의되었습니다.

    {
        // 카메라별 Stop을 병렬 실행합니다. 각 카메라의 Kill/WaitForExitAsync는
        // 비동기이므로 N대 정지가 1대 정지와 거의 같은 시간 안에 완료됩니다.
        CameraDevice[] cameras = _repository.GetAll().ToArray();
        Task[] tasks = cameras
            .Select(camera => StopAsync(camera.Id, cancellationToken))
            .ToArray();
 
        await Task.WhenAll(tasks);
    }

다음을 참조함 : _repository, DreamineVMS.Models.CameraDevice.Id, StopAsync().

다음에 의해서 참조됨 : StopAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StopAsync() [1/2]

override async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StopAsync ( CancellationToken cancellationToken )

inline

Stop Async 작업을 수행합니다.

매개변수

cancellationToken 취소 요청을 감시하는 토큰입니다.

반환값: Stop Async 작업에서 생성한 Task 결과입니다.

FfmpegHlsStreamService.cs 파일의 314 번째 라인에서 정의되었습니다.

    {
        await StopAllAsync(cancellationToken);
        await base.StopAsync(cancellationToken);
        _processJob?.Dispose();
    }

다음을 참조함 : _processJob, StopAllAsync().

다음에 의해서 참조됨 : StopAllAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ StopAsync() [2/2]

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StopAsync	(	string	cameraId,
		CancellationToken	cancellationToken = default )

inline

Stop Async 작업을 수행합니다.

매개변수

cameraId	camera Id에 사용할 `string` 값입니다.
cancellationToken	취소 요청을 감시하는 토큰입니다.

반환값: Stop Async 작업에서 생성한 Task 결과입니다.

DreamineVMS.Services.Streaming.ICameraStreamService를 구현.

FfmpegHlsStreamService.cs 파일의 522 번째 라인에서 정의되었습니다.

    {
        SemaphoreSlim cameraLock = GetCameraOperationLock(cameraId);
        await cameraLock.WaitAsync(cancellationToken);
        try
        {
            await StopInternalAsync(cameraId, cancellationToken);
        }
        finally
        {
            cameraLock.Release();
        }
    }

다음을 참조함 : GetCameraOperationLock(), StopInternalAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

◆ StopInternalAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.StopInternalAsync	(	string	cameraId,
		CancellationToken	cancellationToken )

inlineprivate

Stop Internal Async 작업을 수행합니다.

매개변수

cameraId	camera Id에 사용할 `string` 값입니다.
cancellationToken	취소 요청을 감시하는 토큰입니다.

반환값: Stop Internal Async 작업에서 생성한 Task 결과입니다.

FfmpegHlsStreamService.cs 파일의 664 번째 라인에서 정의되었습니다.

    {
        Process? toStop = null;
        await _sync.WaitAsync(cancellationToken);
        try
        {
            if (_processes.TryGetValue(cameraId, out toStop))
            {
                _intentionalStops.TryAdd(cameraId, 0);
                _processes.Remove(cameraId);
            }
        }
        finally
        {
            _sync.Release();
        }
 
        if (toStop is not null)
        {
            _runtimeState.SetState(cameraId, CameraConnectionState.Disconnected, $"Stopping camera: {cameraId}");
            await Task.Delay(TimeSpan.FromMilliseconds(700), cancellationToken);
            await ShutdownProcessAsync(cameraId, toStop, cancellationToken);
            CleanupOldSegmentFiles(cameraId, TimeSpan.FromMinutes(30));
        }
 
        await _sync.WaitAsync(cancellationToken);
        try
        {
            _lastSequences.Remove(cameraId);
            _lastWrites.Remove(cameraId);
        }
        finally
        {
            _sync.Release();
        }
 
        _runtimeState.SetState(cameraId, CameraConnectionState.Disconnected, $"Camera stopped: {cameraId}");
        _intentionalStops.TryRemove(cameraId, out _);
    }

다음을 참조함 : _intentionalStops, _lastSequences, _lastWrites, _processes, _runtimeState, _sync, CleanupOldSegmentFiles(), ShutdownProcessAsync().

다음에 의해서 참조됨 : StopAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

◆ WatchdogAsync()

async Task DreamineVMS.Services.Streaming.FfmpegHlsStreamService.WatchdogAsync ( CancellationToken cancellationToken )

inlineprivate

Watchdog Async 작업을 수행합니다.

매개변수

cancellationToken 취소 요청을 감시하는 토큰입니다.

반환값: Watchdog Async 작업에서 생성한 Task 결과입니다.

FfmpegHlsStreamService.cs 파일의 728 번째 라인에서 정의되었습니다.

    {
        foreach (CameraDevice camera in _repository.GetAll().Where(camera => camera.Enabled && camera.AutoReconnect && !camera.IsDirectHls))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return;
            }
 
            // 의도적 정지 진행 중인 카메라는 자동 재시작 대상에서 제외합니다.
            if (_intentionalStops.ContainsKey(camera.Id))
            {
                continue;
            }
 
            Process? deadProcess = null;
            bool needRestart = false;
 
            await _sync.WaitAsync(cancellationToken);
            try
            {
                if (!_processes.TryGetValue(camera.Id, out Process? process) || process.HasExited)
                {
                    if (_processes.ContainsKey(camera.Id))
                    {
                        _runtimeState.IncrementRestart(camera.Id, $"FFmpeg process exited. Restarting: {camera.Name}");
                        deadProcess = _processes[camera.Id];
                        _processes.Remove(camera.Id);
                        needRestart = true;
                    }
                    else
                    {
                        // 한 번도 시작 안 됐거나 깨끗하게 정지된 카메라는 watchdog 대상 아님.
                        continue;
                    }
                }
                else
                {
                    string m3u8Path = GetPlaylistPath(camera.Id);
                    if (!File.Exists(m3u8Path))
                    {
                        continue;
                    }
 
                    (long sequence, DateTime writeTime) = ReadSequenceAndWriteTime(m3u8Path);
                    long lastSequence = _lastSequences.GetValueOrDefault(camera.Id, -1);
                    DateTime lastWrite = _lastWrites.GetValueOrDefault(camera.Id, DateTime.MinValue);
 
                    if (sequence > lastSequence || writeTime > lastWrite)
                    {
                        _lastSequences[camera.Id] = Math.Max(sequence, lastSequence);
                        _lastWrites[camera.Id] = writeTime > lastWrite ? writeTime : lastWrite;
                        _runtimeState.SetState(camera.Id, CameraConnectionState.Connected, $"HLS updated: {camera.Name}");
                        continue;
                    }
 
                    double idleSeconds = (DateTime.UtcNow - lastWrite.ToUniversalTime()).TotalSeconds;
                    int idleLimit = Math.Max(
                        _options.WatchdogIdleSeconds > 0 ? _options.WatchdogIdleSeconds : 6,
                        _options.HlsSegmentSeconds * _options.HlsListSize);
 
                    if (idleSeconds >= idleLimit)
                    {
                        _runtimeState.IncrementRestart(camera.Id, $"HLS idle timeout. Restarting: {camera.Name}");
                        deadProcess = process;
                        _processes.Remove(camera.Id);
                        needRestart = true;
                    }
                }
            }
            finally
            {
                _sync.Release();
            }
 
            if (deadProcess is not null)
            {
                await ShutdownProcessAsync(camera.Id, deadProcess, cancellationToken);
            }
 
            if (needRestart)
            {
                try
                {
                    await Task.Delay(
                        TimeSpan.FromSeconds(Math.Max(0, _options.RestartDelaySeconds)),
                        cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    return;
                }
 
                await _sync.WaitAsync(cancellationToken);
                try
                {
                    StartProcessUnsafe(camera);
                }
                finally
                {
                    _sync.Release();
                }
            }
        }
    }

다음을 참조함 : _intentionalStops, _lastSequences, _lastWrites, _options, _processes, _repository, _runtimeState, _sync, DreamineVMS.Models.CameraDevice.AutoReconnect, DreamineVMS.Models.CameraDevice.Enabled, GetPlaylistPath(), DreamineVMS.Models.CameraDevice.Id, DreamineVMS.Models.CameraDevice.IsDirectHls, ReadSequenceAndWriteTime(), sequence, ShutdownProcessAsync(), StartProcessUnsafe().

다음에 의해서 참조됨 : ExecuteAsync().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

◆ _cameraOperationLocks

readonly ConcurrentDictionary<string, SemaphoreSlim> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._cameraOperationLocks = new()

private

camera Operation Locks 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 126 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose(), GetCameraOperationLock().

◆ _disposed

bool DreamineVMS.Services.Streaming.FfmpegHlsStreamService._disposed

private

disposed 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 167 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose().

◆ _intentionalStops

readonly ConcurrentDictionary<string, byte> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._intentionalStops = new()

private

의도된 정지(StopAsync / Restart)로 인해 곧 종료될 프로세스의 카메라 ID 집합입니다. process.Exited 이벤트 핸들러는 이 집합에 포함된 카메라에 대해서는 Faulted 상태를 덮어쓰지 않습니다.

FfmpegHlsStreamService.cs 파일의 136 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose(), StartInternalAsync(), StartProcessUnsafe(), StopInternalAsync(), WatchdogAsync().

◆ _lastSequences

readonly Dictionary<string, long> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._lastSequences = new()

private

last Sequences 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 108 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : InitWatchStats(), StartInternalAsync(), StopInternalAsync(), WatchdogAsync().

◆ _lastWrites

readonly Dictionary<string, DateTime> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._lastWrites = new()

private

last Writes 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 117 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : InitWatchStats(), StartInternalAsync(), StopInternalAsync(), WatchdogAsync().

◆ _logger

readonly ILogger<FfmpegHlsStreamService> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._logger

private

logger 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 63 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : ExecuteAsync(), FfmpegHlsStreamService(), ForceKillProcessUnsafe(), PreparePlaylistForNewSession(), ShutdownProcessAsync(), StartProcessUnsafe().

◆ _options

readonly FfmpegOptions DreamineVMS.Services.Streaming.FfmpegHlsStreamService._options

private

options 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 90 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : BuildArguments(), ExecuteAsync(), FfmpegHlsStreamService(), GetOutputRoot(), StartProcessUnsafe(), WatchdogAsync().

◆ _processes

readonly Dictionary<string, Process> DreamineVMS.Services.Streaming.FfmpegHlsStreamService._processes = new()

private

processes 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 99 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose(), ForceKillProcessUnsafe(), StartInternalAsync(), StartProcessUnsafe(), StopInternalAsync(), WatchdogAsync().

◆ _processJob

readonly? ChildProcessJob DreamineVMS.Services.Streaming.FfmpegHlsStreamService._processJob

private

초기값:

=

OperatingSystem.IsWindows() ? new ChildProcessJob() : null

DreamineVMS.Services.Streaming.ChildProcessJob

Definition ChildProcessJob.cs:26

자식 ffmpeg 프로세스를 부모와 묶는 Windows Job Object입니다.

FfmpegHlsStreamService.cs 파일의 156 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose(), StartProcessUnsafe(), StopAsync().

◆ _repository

readonly IVmsCameraRepository DreamineVMS.Services.Streaming.FfmpegHlsStreamService._repository

private

repository 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 72 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : FfmpegHlsStreamService(), StartAllAsync(), StartInternalAsync(), StopAllAsync(), WatchdogAsync().

◆ _runtimeState

readonly ICameraRuntimeStateService DreamineVMS.Services.Streaming.FfmpegHlsStreamService._runtimeState

private

runtime State 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 81 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : FfmpegHlsStreamService(), StartInternalAsync(), StartProcessUnsafe(), StopInternalAsync(), WatchdogAsync().

◆ _sync

readonly SemaphoreSlim DreamineVMS.Services.Streaming.FfmpegHlsStreamService._sync = new(1, 1)

private

sync 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 146 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : Dispose(), StartInternalAsync(), StopInternalAsync(), WatchdogAsync().

◆ GracefulExitTimeout

readonly TimeSpan DreamineVMS.Services.Streaming.FfmpegHlsStreamService.GracefulExitTimeout = TimeSpan.FromMilliseconds(800)

staticprivate

ffmpeg에 'q'를 보내고 graceful exit를 기다리는 최대 시간입니다.

FfmpegHlsStreamService.cs 파일의 43 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : ShutdownProcessAsync().

◆ KillWaitTimeout

readonly TimeSpan DreamineVMS.Services.Streaming.FfmpegHlsStreamService.KillWaitTimeout = TimeSpan.FromSeconds(2)

staticprivate

Kill 이후 프로세스 종료를 기다리는 최대 시간입니다.

FfmpegHlsStreamService.cs 파일의 53 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : ShutdownProcessAsync().

◆ MediaSeqRegex

readonly Regex DreamineVMS.Services.Streaming.FfmpegHlsStreamService.MediaSeqRegex = new(@"#EXT-X-MEDIA-SEQUENCE:(\d+)", RegexOptions.Compiled)

staticprivate

Media Seq Regex 값을 보관합니다.

FfmpegHlsStreamService.cs 파일의 33 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : ReadSequenceAndWriteTime().

◆ sequence

long DreamineVMS.Services.Streaming.FfmpegHlsStreamService.sequence

staticprivate

Sequence And Write Time 데이터를 읽습니다.

매개변수

path	path에 사용할 `string` 값입니다.

반환값: Read Sequence And Write Time 작업에서 생성한 (long sequence, DateTime writeTime) 결과입니다.

FfmpegHlsStreamService.cs 파일의 1294 번째 라인에서 정의되었습니다.

다음에 의해서 참조됨 : InitWatchStats(), ReadSequenceAndWriteTime(), WatchdogAsync().

이 클래스에 대한 문서화 페이지는 다음의 파일로부터 생성되었습니다.:

FfmpegHlsStreamService.cs

Public 멤버 함수

Protected 멤버 함수

Private 멤버 함수

정적 Private 멤버 함수

Private 속성

정적 Private 속성

상세한 설명

생성자 & 소멸자 문서화

◆ FfmpegHlsStreamService()

멤버 함수 문서화

◆ BuildArguments()

◆ CleanupOldSegmentFiles()

◆ Dispose()

◆ ExecuteAsync()

◆ ForceKillProcessUnsafe()

◆ GetCameraOperationLock()

◆ GetCameraOutputDirectory()

◆ GetOutputRoot()

◆ GetPlaylistPath()

◆ InitWatchStats()

◆ PreparePlaylistForNewSession()

◆ Quote()

◆ ReadSequenceAndWriteTime()

◆ ShutdownProcessAsync()

◆ StartAllAsync()

◆ StartAsync()

◆ StartInternalAsync()

◆ StartProcessUnsafe()

◆ StopAllAsync()

◆ StopAsync() [1/2]

◆ StopAsync() [2/2]

◆ StopInternalAsync()

◆ WatchdogAsync()

멤버 데이터 문서화

◆ _cameraOperationLocks

◆ _disposed

◆ _intentionalStops

◆ _lastSequences

◆ _lastWrites

◆ _logger

◆ _options

◆ _processes

◆ _processJob

◆ _repository

◆ _runtimeState

◆ _sync

◆ GracefulExitTimeout

◆ KillWaitTimeout

◆ MediaSeqRegex

◆ sequence