< Summary - Jellyfin

Information
Class: MediaBrowser.MediaEncoding.Transcoding.TranscodeManager
Assembly: MediaBrowser.MediaEncoding
File(s): /srv/git/jellyfin/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
Line coverage
15%
Covered lines: 30
Uncovered lines: 166
Coverable lines: 196
Total lines: 762
Line coverage: 15.3%
Branch coverage
2%
Covered branches: 2
Total branches: 76
Branch coverage: 2.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetTranscodingJob(...)100%210%
GetTranscodingJob(...)100%210%
PingTranscodingJob(...)0%2040%
PingTimer(...)0%7280%
KillTranscodingJobs(...)100%210%
DeleteProgressivePartialStreamFiles(...)0%620%
DeleteHlsPartialStreamFiles(...)0%7280%
ReportTranscodingProgress(...)0%7280%
StartThrottler(...)0%4260%
EnableThrottling(...)0%7280%
StartSegmentCleaner(...)0%620%
EnableSegmentCleaning(...)0%110100%
OnTranscodeBeginning(...)100%210%
OnTranscodeEndRequest(...)0%620%
OnTranscodeFailedToStart(...)0%2040%
OnFfMpegProcessExited(...)0%620%
OnTranscodeBeginRequest(...)0%4260%
OnPlaybackProgress(...)0%620%
DeleteEncodedMediaCache()50%7440%
LockAsync(...)100%210%
Dispose()100%11100%

File(s)

/srv/git/jellyfin/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Diagnostics;
 4using System.Globalization;
 5using System.IO;
 6using System.Linq;
 7using System.Runtime.CompilerServices;
 8using System.Text;
 9using System.Text.Json;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using AsyncKeyedLock;
 13using Jellyfin.Data;
 14using Jellyfin.Database.Implementations.Enums;
 15using Jellyfin.Extensions;
 16using MediaBrowser.Common;
 17using MediaBrowser.Common.Configuration;
 18using MediaBrowser.Common.Extensions;
 19using MediaBrowser.Controller.Configuration;
 20using MediaBrowser.Controller.Library;
 21using MediaBrowser.Controller.MediaEncoding;
 22using MediaBrowser.Controller.Session;
 23using MediaBrowser.Controller.Streaming;
 24using MediaBrowser.Model.Dlna;
 25using MediaBrowser.Model.Entities;
 26using MediaBrowser.Model.IO;
 27using MediaBrowser.Model.MediaInfo;
 28using MediaBrowser.Model.Session;
 29using Microsoft.Extensions.Logging;
 30
 31namespace MediaBrowser.MediaEncoding.Transcoding;
 32
 33/// <inheritdoc cref="ITranscodeManager"/>
 34public sealed class TranscodeManager : ITranscodeManager, IDisposable
 35{
 36    private readonly ILoggerFactory _loggerFactory;
 37    private readonly ILogger<TranscodeManager> _logger;
 38    private readonly IFileSystem _fileSystem;
 39    private readonly IApplicationPaths _appPaths;
 40    private readonly IServerConfigurationManager _serverConfigurationManager;
 41    private readonly IUserManager _userManager;
 42    private readonly ISessionManager _sessionManager;
 43    private readonly EncodingHelper _encodingHelper;
 44    private readonly IMediaEncoder _mediaEncoder;
 45    private readonly IMediaSourceManager _mediaSourceManager;
 46    private readonly IAttachmentExtractor _attachmentExtractor;
 47
 248    private readonly List<TranscodingJob> _activeTranscodingJobs = new();
 249    private readonly AsyncKeyedLocker<string> _transcodingLocks = new(o =>
 250    {
 251        o.PoolSize = 20;
 252        o.PoolInitialFill = 1;
 253    });
 54
 255    private readonly Version _maxFFmpegCkeyPauseSupported = new Version(6, 1);
 56
 57    /// <summary>
 58    /// Initializes a new instance of the <see cref="TranscodeManager"/> class.
 59    /// </summary>
 60    /// <param name="loggerFactory">The <see cref="ILoggerFactory"/>.</param>
 61    /// <param name="fileSystem">The <see cref="IFileSystem"/>.</param>
 62    /// <param name="appPaths">The <see cref="IApplicationPaths"/>.</param>
 63    /// <param name="serverConfigurationManager">The <see cref="IServerConfigurationManager"/>.</param>
 64    /// <param name="userManager">The <see cref="IUserManager"/>.</param>
 65    /// <param name="sessionManager">The <see cref="ISessionManager"/>.</param>
 66    /// <param name="encodingHelper">The <see cref="EncodingHelper"/>.</param>
 67    /// <param name="mediaEncoder">The <see cref="IMediaEncoder"/>.</param>
 68    /// <param name="mediaSourceManager">The <see cref="IMediaSourceManager"/>.</param>
 69    /// <param name="attachmentExtractor">The <see cref="IAttachmentExtractor"/>.</param>
 70    public TranscodeManager(
 71        ILoggerFactory loggerFactory,
 72        IFileSystem fileSystem,
 73        IApplicationPaths appPaths,
 74        IServerConfigurationManager serverConfigurationManager,
 75        IUserManager userManager,
 76        ISessionManager sessionManager,
 77        EncodingHelper encodingHelper,
 78        IMediaEncoder mediaEncoder,
 79        IMediaSourceManager mediaSourceManager,
 80        IAttachmentExtractor attachmentExtractor)
 81    {
 282        _loggerFactory = loggerFactory;
 283        _fileSystem = fileSystem;
 284        _appPaths = appPaths;
 285        _serverConfigurationManager = serverConfigurationManager;
 286        _userManager = userManager;
 287        _sessionManager = sessionManager;
 288        _encodingHelper = encodingHelper;
 289        _mediaEncoder = mediaEncoder;
 290        _mediaSourceManager = mediaSourceManager;
 291        _attachmentExtractor = attachmentExtractor;
 92
 293        _logger = loggerFactory.CreateLogger<TranscodeManager>();
 294        DeleteEncodedMediaCache();
 295        _sessionManager.PlaybackProgress += OnPlaybackProgress;
 296        _sessionManager.PlaybackStart += OnPlaybackProgress;
 297    }
 98
 99    /// <inheritdoc />
 100    public TranscodingJob? GetTranscodingJob(string playSessionId)
 101    {
 0102        lock (_activeTranscodingJobs)
 103        {
 0104            return _activeTranscodingJobs.FirstOrDefault(j => string.Equals(j.PlaySessionId, playSessionId, StringCompar
 105        }
 0106    }
 107
 108    /// <inheritdoc />
 109    public TranscodingJob? GetTranscodingJob(string path, TranscodingJobType type)
 110    {
 0111        lock (_activeTranscodingJobs)
 112        {
 0113            return _activeTranscodingJobs.FirstOrDefault(j => j.Type == type && string.Equals(j.Path, path, StringCompar
 114        }
 0115    }
 116
 117    /// <inheritdoc />
 118    public void PingTranscodingJob(string playSessionId, bool? isUserPaused)
 119    {
 0120        ArgumentException.ThrowIfNullOrEmpty(playSessionId);
 121
 0122        _logger.LogDebug("PingTranscodingJob PlaySessionId={0} isUsedPaused: {1}", playSessionId, isUserPaused);
 123
 124        List<TranscodingJob> jobs;
 125
 0126        lock (_activeTranscodingJobs)
 127        {
 128            // This is really only needed for HLS.
 129            // Progressive streams can stop on their own reliably.
 0130            jobs = _activeTranscodingJobs.Where(j => string.Equals(playSessionId, j.PlaySessionId, StringComparison.Ordi
 0131        }
 132
 0133        foreach (var job in jobs)
 134        {
 0135            if (isUserPaused.HasValue)
 136            {
 0137                _logger.LogDebug("Setting job.IsUserPaused to {0}. jobId: {1}", isUserPaused, job.Id);
 0138                job.IsUserPaused = isUserPaused.Value;
 139            }
 140
 0141            PingTimer(job, true);
 142        }
 0143    }
 144
 145    private void PingTimer(TranscodingJob job, bool isProgressCheckIn)
 146    {
 0147        if (job.HasExited)
 148        {
 0149            job.StopKillTimer();
 0150            return;
 151        }
 152
 0153        var timerDuration = 10000;
 154
 0155        if (job.Type != TranscodingJobType.Progressive)
 156        {
 0157            timerDuration = 60000;
 158        }
 159
 0160        job.PingTimeout = timerDuration;
 0161        job.LastPingDate = DateTime.UtcNow;
 162
 163        // Don't start the timer for playback checkins with progressive streaming
 0164        if (job.Type != TranscodingJobType.Progressive || !isProgressCheckIn)
 165        {
 0166            job.StartKillTimer(OnTranscodeKillTimerStopped);
 167        }
 168        else
 169        {
 0170            job.ChangeKillTimerIfStarted();
 171        }
 0172    }
 173
 174    private async void OnTranscodeKillTimerStopped(object? state)
 175    {
 176        var job = state as TranscodingJob ?? throw new ArgumentException($"{nameof(state)} is not of type {nameof(Transc
 177        if (!job.HasExited && job.Type != TranscodingJobType.Progressive)
 178        {
 179            var timeSinceLastPing = (DateTime.UtcNow - job.LastPingDate).TotalMilliseconds;
 180
 181            if (timeSinceLastPing < job.PingTimeout)
 182            {
 183                job.StartKillTimer(OnTranscodeKillTimerStopped, job.PingTimeout);
 184                return;
 185            }
 186        }
 187
 188        _logger.LogInformation("Transcoding kill timer stopped for JobId {0} PlaySessionId {1}. Killing transcoding", jo
 189
 190        await KillTranscodingJob(job, true, path => true).ConfigureAwait(false);
 191    }
 192
 193    /// <inheritdoc />
 194    public Task KillTranscodingJobs(string deviceId, string? playSessionId, Func<string, bool> deleteFiles)
 195    {
 0196        var jobs = new List<TranscodingJob>();
 197
 0198        lock (_activeTranscodingJobs)
 199        {
 200            // This is really only needed for HLS.
 201            // Progressive streams can stop on their own reliably.
 0202            jobs.AddRange(_activeTranscodingJobs.Where(j => string.IsNullOrWhiteSpace(playSessionId)
 0203                ? string.Equals(deviceId, j.DeviceId, StringComparison.OrdinalIgnoreCase)
 0204                : string.Equals(playSessionId, j.PlaySessionId, StringComparison.OrdinalIgnoreCase)));
 0205        }
 206
 0207        return Task.WhenAll(GetKillJobs());
 208
 209        IEnumerable<Task> GetKillJobs()
 210        {
 211            foreach (var job in jobs)
 212            {
 213                yield return KillTranscodingJob(job, false, deleteFiles);
 214            }
 215        }
 216    }
 217
 218    private async Task KillTranscodingJob(TranscodingJob job, bool closeLiveStream, Func<string, bool> delete)
 219    {
 220        job.DisposeKillTimer();
 221
 222        _logger.LogDebug("KillTranscodingJob - JobId {0} PlaySessionId {1}. Killing transcoding", job.Id, job.PlaySessio
 223
 224        lock (_activeTranscodingJobs)
 225        {
 226            _activeTranscodingJobs.Remove(job);
 227
 228            if (job.CancellationTokenSource?.IsCancellationRequested == false)
 229            {
 230#pragma warning disable CA1849 // Can't await in lock block
 231                job.CancellationTokenSource.Cancel();
 232#pragma warning restore CA1849
 233            }
 234        }
 235
 236        job.Stop();
 237
 238        if (delete(job.Path!))
 239        {
 240            await DeletePartialStreamFiles(job.Path!, job.Type, 0, 1500).ConfigureAwait(false);
 241        }
 242
 243        if (closeLiveStream && !string.IsNullOrWhiteSpace(job.LiveStreamId))
 244        {
 245            await _sessionManager.CloseLiveStreamIfNeededAsync(job.LiveStreamId, job.PlaySessionId).ConfigureAwait(false
 246        }
 247    }
 248
 249    private async Task DeletePartialStreamFiles(string path, TranscodingJobType jobType, int retryCount, int delayMs)
 250    {
 251        if (retryCount >= 10)
 252        {
 253            return;
 254        }
 255
 256        _logger.LogInformation("Deleting partial stream file(s) {Path}", path);
 257
 258        await Task.Delay(delayMs).ConfigureAwait(false);
 259
 260        try
 261        {
 262            if (jobType == TranscodingJobType.Progressive)
 263            {
 264                DeleteProgressivePartialStreamFiles(path);
 265            }
 266            else
 267            {
 268                DeleteHlsPartialStreamFiles(path);
 269            }
 270        }
 271        catch (IOException ex)
 272        {
 273            _logger.LogError(ex, "Error deleting partial stream file(s) {Path}", path);
 274
 275            await DeletePartialStreamFiles(path, jobType, retryCount + 1, 500).ConfigureAwait(false);
 276        }
 277        catch (Exception ex)
 278        {
 279            _logger.LogError(ex, "Error deleting partial stream file(s) {Path}", path);
 280        }
 281    }
 282
 283    private void DeleteProgressivePartialStreamFiles(string outputFilePath)
 284    {
 0285        if (File.Exists(outputFilePath))
 286        {
 0287            _fileSystem.DeleteFile(outputFilePath);
 288        }
 0289    }
 290
 291    private void DeleteHlsPartialStreamFiles(string outputFilePath)
 292    {
 0293        var directory = Path.GetDirectoryName(outputFilePath)
 0294                        ?? throw new ArgumentException("Path can't be a root directory.", nameof(outputFilePath));
 295
 0296        var name = Path.GetFileNameWithoutExtension(outputFilePath);
 297
 0298        var filesToDelete = _fileSystem.GetFilePaths(directory)
 0299            .Where(f => f.Contains(name, StringComparison.OrdinalIgnoreCase));
 300
 0301        List<Exception>? exs = null;
 0302        foreach (var file in filesToDelete)
 303        {
 304            try
 305            {
 0306                _logger.LogDebug("Deleting HLS file {0}", file);
 0307                _fileSystem.DeleteFile(file);
 0308            }
 0309            catch (IOException ex)
 310            {
 0311                (exs ??= new List<Exception>()).Add(ex);
 0312                _logger.LogError(ex, "Error deleting HLS file {Path}", file);
 0313            }
 314        }
 315
 0316        if (exs is not null)
 317        {
 0318            throw new AggregateException("Error deleting HLS files", exs);
 319        }
 0320    }
 321
 322    /// <inheritdoc />
 323    public void ReportTranscodingProgress(
 324        TranscodingJob job,
 325        StreamState state,
 326        TimeSpan? transcodingPosition,
 327        float? framerate,
 328        double? percentComplete,
 329        long? bytesTranscoded,
 330        int? bitRate)
 331    {
 0332        var ticks = transcodingPosition?.Ticks;
 333
 0334        if (job is not null)
 335        {
 0336            job.Framerate = framerate;
 0337            job.CompletionPercentage = percentComplete;
 0338            job.TranscodingPositionTicks = ticks;
 0339            job.BytesTranscoded = bytesTranscoded;
 0340            job.BitRate = bitRate;
 341        }
 342
 0343        var deviceId = state.Request.DeviceId;
 344
 0345        if (!string.IsNullOrWhiteSpace(deviceId))
 346        {
 0347            var audioCodec = state.ActualOutputAudioCodec;
 0348            var videoCodec = state.ActualOutputVideoCodec;
 0349            var hardwareAccelerationType = _serverConfigurationManager.GetEncodingOptions().HardwareAccelerationType;
 350
 0351            _sessionManager.ReportTranscodingInfo(deviceId, new TranscodingInfo
 0352            {
 0353                Bitrate = bitRate ?? state.TotalOutputBitrate,
 0354                AudioCodec = audioCodec,
 0355                VideoCodec = videoCodec,
 0356                Container = state.OutputContainer,
 0357                Framerate = framerate,
 0358                CompletionPercentage = percentComplete,
 0359                Width = state.OutputWidth,
 0360                Height = state.OutputHeight,
 0361                AudioChannels = state.OutputAudioChannels,
 0362                IsAudioDirect = EncodingHelper.IsCopyCodec(state.OutputAudioCodec),
 0363                IsVideoDirect = EncodingHelper.IsCopyCodec(state.OutputVideoCodec),
 0364                HardwareAccelerationType = hardwareAccelerationType,
 0365                TranscodeReasons = state.TranscodeReasons
 0366            });
 367        }
 0368    }
 369
 370    /// <inheritdoc />
 371    public async Task<TranscodingJob> StartFfMpeg(
 372        StreamState state,
 373        string outputPath,
 374        string commandLineArguments,
 375        Guid userId,
 376        TranscodingJobType transcodingJobType,
 377        CancellationTokenSource cancellationTokenSource,
 378        string? workingDirectory = null)
 379    {
 380        var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) 
 381        Directory.CreateDirectory(directory);
 382
 383        await AcquireResources(state, cancellationTokenSource).ConfigureAwait(false);
 384
 385        if (state.VideoRequest is not null && !EncodingHelper.IsCopyCodec(state.OutputVideoCodec))
 386        {
 387            var user = userId.IsEmpty() ? null : _userManager.GetUserById(userId);
 388            if (user is not null && !user.HasPermission(PermissionKind.EnableVideoPlaybackTranscoding))
 389            {
 390                OnTranscodeFailedToStart(outputPath, transcodingJobType, state);
 391
 392                throw new ArgumentException("User does not have access to video transcoding.");
 393            }
 394        }
 395
 396        ArgumentException.ThrowIfNullOrEmpty(_mediaEncoder.EncoderPath);
 397
 398        // If subtitles get burned in fonts may need to be extracted from the media file
 399        if (state.SubtitleStream is not null && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
 400        {
 401            var attachmentPath = Path.Combine(_appPaths.CachePath, "attachments", state.MediaSource.Id);
 402            if (state.MediaSource.VideoType == VideoType.Dvd || state.MediaSource.VideoType == VideoType.BluRay)
 403            {
 404                var concatPath = Path.Join(_appPaths.CachePath, "concat", state.MediaSource.Id + ".concat");
 405                await _attachmentExtractor.ExtractAllAttachments(concatPath, state.MediaSource, attachmentPath, cancella
 406            }
 407            else
 408            {
 409                await _attachmentExtractor.ExtractAllAttachments(state.MediaPath, state.MediaSource, attachmentPath, can
 410            }
 411
 412            if (state.SubtitleStream.IsExternal && Path.GetExtension(state.SubtitleStream.Path.AsSpan()).Equals(".mks", 
 413            {
 414                string subtitlePath = state.SubtitleStream.Path;
 415                string subtitlePathArgument = string.Format(CultureInfo.InvariantCulture, "file:\"{0}\"", subtitlePath.R
 416                string subtitleId = subtitlePath.GetMD5().ToString("N", CultureInfo.InvariantCulture);
 417
 418                await _attachmentExtractor.ExtractAllAttachmentsExternal(subtitlePathArgument, subtitleId, attachmentPat
 419            }
 420        }
 421
 422        var process = new Process
 423        {
 424            StartInfo = new ProcessStartInfo
 425            {
 426                WindowStyle = ProcessWindowStyle.Hidden,
 427                CreateNoWindow = true,
 428                UseShellExecute = false,
 429
 430                // Must consume both stdout and stderr or deadlocks may occur
 431                // RedirectStandardOutput = true,
 432                RedirectStandardError = true,
 433                RedirectStandardInput = true,
 434                FileName = _mediaEncoder.EncoderPath,
 435                Arguments = commandLineArguments,
 436                WorkingDirectory = string.IsNullOrWhiteSpace(workingDirectory) ? string.Empty : workingDirectory,
 437                ErrorDialog = false
 438            },
 439            EnableRaisingEvents = true
 440        };
 441
 442        var transcodingJob = OnTranscodeBeginning(
 443            outputPath,
 444            state.Request.PlaySessionId,
 445            state.MediaSource.LiveStreamId,
 446            Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture),
 447            transcodingJobType,
 448            process,
 449            state.Request.DeviceId,
 450            state,
 451            cancellationTokenSource);
 452
 453        _logger.LogInformation("{Filename} {Arguments}", process.StartInfo.FileName, process.StartInfo.Arguments);
 454
 455        var logFilePrefix = "FFmpeg.Transcode-";
 456        if (state.VideoRequest is not null
 457            && EncodingHelper.IsCopyCodec(state.OutputVideoCodec))
 458        {
 459            logFilePrefix = EncodingHelper.IsCopyCodec(state.OutputAudioCodec)
 460                ? "FFmpeg.Remux-"
 461                : "FFmpeg.DirectStream-";
 462        }
 463
 464        if (state.VideoRequest is null && EncodingHelper.IsCopyCodec(state.OutputAudioCodec))
 465        {
 466            logFilePrefix = "FFmpeg.Remux-";
 467        }
 468
 469        var logFilePath = Path.Combine(
 470            _serverConfigurationManager.ApplicationPaths.LogDirectoryPath,
 471            $"{logFilePrefix}{DateTime.Now:yyyy-MM-dd_HH-mm-ss}_{state.Request.MediaSourceId}_{Guid.NewGuid().ToString()
 472
 473        // FFmpeg writes debug/error info to stderr. This is useful when debugging so let's put it in the log directory.
 474        Stream logStream = new FileStream(
 475            logFilePath,
 476            FileMode.Create,
 477            FileAccess.Write,
 478            FileShare.Read,
 479            IODefaults.FileStreamBufferSize,
 480            FileOptions.Asynchronous);
 481
 482        await JsonSerializer.SerializeAsync(logStream, state.MediaSource, cancellationToken: cancellationTokenSource.Tok
 483        var commandLineLogMessageBytes = Encoding.UTF8.GetBytes(
 484            Environment.NewLine
 485            + Environment.NewLine
 486            + process.StartInfo.FileName + " " + process.StartInfo.Arguments
 487            + Environment.NewLine
 488            + Environment.NewLine);
 489
 490        await logStream.WriteAsync(commandLineLogMessageBytes, cancellationTokenSource.Token).ConfigureAwait(false);
 491
 492        process.Exited += (_, _) => OnFfMpegProcessExited(process, transcodingJob, state);
 493
 494        try
 495        {
 496            process.Start();
 497        }
 498        catch (Exception ex)
 499        {
 500            _logger.LogError(ex, "Error starting FFmpeg");
 501            OnTranscodeFailedToStart(outputPath, transcodingJobType, state);
 502
 503            throw;
 504        }
 505
 506        _logger.LogDebug("Launched FFmpeg process");
 507        state.TranscodingJob = transcodingJob;
 508
 509        // Important - don't await the log task or we won't be able to kill FFmpeg when the user stops playback
 510        _ = new JobLogger(_logger).StartStreamingLog(state, process.StandardError, logStream);
 511
 512        // Wait for the file to exist before proceeding
 513        var ffmpegTargetFile = state.WaitForPath ?? outputPath;
 514        _logger.LogDebug("Waiting for the creation of {0}", ffmpegTargetFile);
 515        while (!File.Exists(ffmpegTargetFile) && !transcodingJob.HasExited)
 516        {
 517            await Task.Delay(100, cancellationTokenSource.Token).ConfigureAwait(false);
 518        }
 519
 520        _logger.LogDebug("File {0} created or transcoding has finished", ffmpegTargetFile);
 521
 522        if (state.IsInputVideo && transcodingJob.Type == TranscodingJobType.Progressive && !transcodingJob.HasExited)
 523        {
 524            await Task.Delay(1000, cancellationTokenSource.Token).ConfigureAwait(false);
 525
 526            if (state.ReadInputAtNativeFramerate && !transcodingJob.HasExited)
 527            {
 528                await Task.Delay(1500, cancellationTokenSource.Token).ConfigureAwait(false);
 529            }
 530        }
 531
 532        if (!transcodingJob.HasExited)
 533        {
 534            StartThrottler(state, transcodingJob);
 535            StartSegmentCleaner(state, transcodingJob);
 536        }
 537        else if (transcodingJob.ExitCode != 0)
 538        {
 539            throw new FfmpegException(string.Format(CultureInfo.InvariantCulture, "FFmpeg exited with code {0}", transco
 540        }
 541
 542        _logger.LogDebug("StartFfMpeg() finished successfully");
 543
 544        return transcodingJob;
 545    }
 546
 547    private void StartThrottler(StreamState state, TranscodingJob transcodingJob)
 548    {
 0549        if (EnableThrottling(state)
 0550            && (_mediaEncoder.IsPkeyPauseSupported
 0551                || _mediaEncoder.EncoderVersion <= _maxFFmpegCkeyPauseSupported))
 552        {
 0553            transcodingJob.TranscodingThrottler = new TranscodingThrottler(transcodingJob, _loggerFactory.CreateLogger<T
 0554            transcodingJob.TranscodingThrottler.Start();
 555        }
 0556    }
 557
 558    private static bool EnableThrottling(StreamState state)
 0559        => state.InputProtocol == MediaProtocol.File
 0560           && state.RunTimeTicks.HasValue
 0561           && state.RunTimeTicks.Value >= TimeSpan.FromMinutes(5).Ticks
 0562           && state.IsInputVideo
 0563           && state.VideoType == VideoType.VideoFile;
 564
 565    private void StartSegmentCleaner(StreamState state, TranscodingJob transcodingJob)
 566    {
 0567        if (EnableSegmentCleaning(state))
 568        {
 0569            transcodingJob.TranscodingSegmentCleaner = new TranscodingSegmentCleaner(transcodingJob, _loggerFactory.Crea
 0570            transcodingJob.TranscodingSegmentCleaner.Start();
 571        }
 0572    }
 573
 574    private static bool EnableSegmentCleaning(StreamState state)
 0575        => state.InputProtocol is MediaProtocol.File or MediaProtocol.Http
 0576           && state.IsInputVideo
 0577           && state.TranscodingType == TranscodingJobType.Hls
 0578           && state.RunTimeTicks.HasValue
 0579           && state.RunTimeTicks.Value >= TimeSpan.FromMinutes(5).Ticks;
 580
 581    private TranscodingJob OnTranscodeBeginning(
 582        string path,
 583        string? playSessionId,
 584        string? liveStreamId,
 585        string transcodingJobId,
 586        TranscodingJobType type,
 587        Process process,
 588        string? deviceId,
 589        StreamState state,
 590        CancellationTokenSource cancellationTokenSource)
 591    {
 0592        lock (_activeTranscodingJobs)
 593        {
 0594            var job = new TranscodingJob(_loggerFactory.CreateLogger<TranscodingJob>())
 0595            {
 0596                Type = type,
 0597                Path = path,
 0598                Process = process,
 0599                ActiveRequestCount = 1,
 0600                DeviceId = deviceId,
 0601                CancellationTokenSource = cancellationTokenSource,
 0602                Id = transcodingJobId,
 0603                PlaySessionId = playSessionId,
 0604                LiveStreamId = liveStreamId,
 0605                MediaSource = state.MediaSource
 0606            };
 607
 0608            _activeTranscodingJobs.Add(job);
 609
 0610            ReportTranscodingProgress(job, state, null, null, null, null, null);
 611
 0612            return job;
 613        }
 0614    }
 615
 616    /// <inheritdoc />
 617    public void OnTranscodeEndRequest(TranscodingJob job)
 618    {
 0619        job.ActiveRequestCount--;
 0620        _logger.LogDebug("OnTranscodeEndRequest job.ActiveRequestCount={ActiveRequestCount}", job.ActiveRequestCount);
 0621        if (job.ActiveRequestCount <= 0)
 622        {
 0623            PingTimer(job, false);
 624        }
 0625    }
 626
 627    private void OnTranscodeFailedToStart(string path, TranscodingJobType type, StreamState state)
 628    {
 0629        lock (_activeTranscodingJobs)
 630        {
 0631            var job = _activeTranscodingJobs.FirstOrDefault(j => j.Type == type && string.Equals(j.Path, path, StringCom
 632
 0633            if (job is not null)
 634            {
 0635                _activeTranscodingJobs.Remove(job);
 636            }
 0637        }
 638
 0639        if (!string.IsNullOrWhiteSpace(state.Request.DeviceId))
 640        {
 0641            _sessionManager.ClearTranscodingInfo(state.Request.DeviceId);
 642        }
 0643    }
 644
 645    private void OnFfMpegProcessExited(Process process, TranscodingJob job, StreamState state)
 646    {
 0647        job.HasExited = true;
 0648        job.ExitCode = process.ExitCode;
 649
 0650        ReportTranscodingProgress(job, state, null, null, null, null, null);
 651
 0652        _logger.LogDebug("Disposing stream resources");
 0653        state.Dispose();
 654
 0655        if (process.ExitCode == 0)
 656        {
 0657            _logger.LogInformation("FFmpeg exited with code 0");
 658        }
 659        else
 660        {
 0661            _logger.LogError("FFmpeg exited with code {0}", process.ExitCode);
 662        }
 663
 0664        job.Dispose();
 0665    }
 666
 667    private async Task AcquireResources(StreamState state, CancellationTokenSource cancellationTokenSource)
 668    {
 669        if (state.MediaSource.RequiresOpening && string.IsNullOrWhiteSpace(state.Request.LiveStreamId))
 670        {
 671            var liveStreamResponse = await _mediaSourceManager.OpenLiveStream(
 672                    new LiveStreamRequest { OpenToken = state.MediaSource.OpenToken },
 673                    cancellationTokenSource.Token)
 674                .ConfigureAwait(false);
 675            var encodingOptions = _serverConfigurationManager.GetEncodingOptions();
 676
 677            _encodingHelper.AttachMediaSourceInfo(state, encodingOptions, liveStreamResponse.MediaSource, state.Requeste
 678
 679            if (state.VideoRequest is not null)
 680            {
 681                _encodingHelper.TryStreamCopy(state);
 682            }
 683        }
 684
 685        if (state.MediaSource.BufferMs.HasValue)
 686        {
 687            await Task.Delay(state.MediaSource.BufferMs.Value, cancellationTokenSource.Token).ConfigureAwait(false);
 688        }
 689    }
 690
 691    /// <inheritdoc />
 692    public TranscodingJob? OnTranscodeBeginRequest(string path, TranscodingJobType type)
 693    {
 0694        lock (_activeTranscodingJobs)
 695        {
 0696            var job = _activeTranscodingJobs
 0697                .FirstOrDefault(j => j.Type == type && string.Equals(j.Path, path, StringComparison.OrdinalIgnoreCase));
 698
 0699            if (job is null)
 700            {
 0701                return null;
 702            }
 703
 0704            job.ActiveRequestCount++;
 0705            if (string.IsNullOrWhiteSpace(job.PlaySessionId) || job.Type == TranscodingJobType.Progressive)
 706            {
 0707                job.StopKillTimer();
 708            }
 709
 0710            return job;
 711        }
 0712    }
 713
 714    private void OnPlaybackProgress(object? sender, PlaybackProgressEventArgs e)
 715    {
 0716        if (!string.IsNullOrWhiteSpace(e.PlaySessionId))
 717        {
 0718            PingTranscodingJob(e.PlaySessionId, e.IsPaused);
 719        }
 0720    }
 721
 722    private void DeleteEncodedMediaCache()
 723    {
 2724        var path = _serverConfigurationManager.GetTranscodePath();
 2725        if (!Directory.Exists(path))
 726        {
 0727            return;
 728        }
 729
 4730        foreach (var file in _fileSystem.GetFilePaths(path, true))
 731        {
 732            try
 733            {
 0734                _fileSystem.DeleteFile(file);
 0735            }
 0736            catch (Exception ex)
 737            {
 0738                _logger.LogError(ex, "Error deleting encoded media cache file {Path}", path);
 0739            }
 740        }
 2741    }
 742
 743    /// <summary>
 744    /// Transcoding lock.
 745    /// </summary>
 746    /// <param name="outputPath">The output path of the transcoded file.</param>
 747    /// <param name="cancellationToken">The cancellation token.</param>
 748    /// <returns>An <see cref="IDisposable"/>.</returns>
 749    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 750    public ValueTask<IDisposable> LockAsync(string outputPath, CancellationToken cancellationToken)
 751    {
 0752        return _transcodingLocks.LockAsync(outputPath, cancellationToken);
 753    }
 754
 755    /// <inheritdoc />
 756    public void Dispose()
 757    {
 2758        _sessionManager.PlaybackProgress -= OnPlaybackProgress;
 2759        _sessionManager.PlaybackStart -= OnPlaybackProgress;
 2760        _transcodingLocks.Dispose();
 2761    }
 762}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:22 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.Extensions.Logging.ILoggerFactory,MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Common.Configuration.IApplicationPaths,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Session.ISessionManager,MediaBrowser.Controller.MediaEncoding.EncodingHelper,MediaBrowser.Controller.MediaEncoding.IMediaEncoder,MediaBrowser.Controller.Library.IMediaSourceManager,MediaBrowser.Controller.MediaEncoding.IAttachmentExtractor)
GetTranscodingJob(System.String)
GetTranscodingJob(System.String,MediaBrowser.Controller.MediaEncoding.TranscodingJobType)
PingTranscodingJob(System.String,System.Nullable`1<System.Boolean>)
PingTimer(MediaBrowser.Controller.MediaEncoding.TranscodingJob,System.Boolean)
KillTranscodingJobs(System.String,System.String,System.Func`2<System.String,System.Boolean>)
DeleteProgressivePartialStreamFiles(System.String)
DeleteHlsPartialStreamFiles(System.String)
ReportTranscodingProgress(MediaBrowser.Controller.MediaEncoding.TranscodingJob,MediaBrowser.Controller.Streaming.StreamState,System.Nullable`1<System.TimeSpan>,System.Nullable`1<System.Single>,System.Nullable`1<System.Double>,System.Nullable`1<System.Int64>,System.Nullable`1<System.Int32>)
StartThrottler(MediaBrowser.Controller.Streaming.StreamState,MediaBrowser.Controller.MediaEncoding.TranscodingJob)
EnableThrottling(MediaBrowser.Controller.Streaming.StreamState)
StartSegmentCleaner(MediaBrowser.Controller.Streaming.StreamState,MediaBrowser.Controller.MediaEncoding.TranscodingJob)
EnableSegmentCleaning(MediaBrowser.Controller.Streaming.StreamState)
OnTranscodeBeginning(System.String,System.String,System.String,System.String,MediaBrowser.Controller.MediaEncoding.TranscodingJobType,System.Diagnostics.Process,System.String,MediaBrowser.Controller.Streaming.StreamState,System.Threading.CancellationTokenSource)
OnTranscodeEndRequest(MediaBrowser.Controller.MediaEncoding.TranscodingJob)
OnTranscodeFailedToStart(System.String,MediaBrowser.Controller.MediaEncoding.TranscodingJobType,MediaBrowser.Controller.Streaming.StreamState)
OnFfMpegProcessExited(System.Diagnostics.Process,MediaBrowser.Controller.MediaEncoding.TranscodingJob,MediaBrowser.Controller.Streaming.StreamState)
OnTranscodeBeginRequest(System.String,MediaBrowser.Controller.MediaEncoding.TranscodingJobType)
OnPlaybackProgress(System.Object,MediaBrowser.Controller.Library.PlaybackProgressEventArgs)
DeleteEncodedMediaCache()
LockAsync(System.String,System.Threading.CancellationToken)
Dispose()