< Summary - Jellyfin

Information
Class: Jellyfin.Server.Migrations.PreStartupRoutines.MigrateEncodingOptions
Assembly: jellyfin
File(s): /srv/git/jellyfin/Jellyfin.Server/Migrations/PreStartupRoutines/MigrateEncodingOptions.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 90
Coverable lines: 90
Total lines: 245
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 14
Branch coverage: 0%
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%210%
get_Id()100%210%
get_Name()100%210%
get_PerformOnNewInstall()100%210%
Perform()0%210140%

File(s)

/srv/git/jellyfin/Jellyfin.Server/Migrations/PreStartupRoutines/MigrateEncodingOptions.cs

#LineLine coverage
 1using System;
 2using System.IO;
 3using System.Xml;
 4using System.Xml.Serialization;
 5using Emby.Server.Implementations;
 6using MediaBrowser.Model.Configuration;
 7using MediaBrowser.Model.Entities;
 8using Microsoft.Extensions.Logging;
 9
 10namespace Jellyfin.Server.Migrations.PreStartupRoutines;
 11
 12/// <inheritdoc />
 13public class MigrateEncodingOptions : IMigrationRoutine
 14{
 15    private readonly ServerApplicationPaths _applicationPaths;
 16    private readonly ILogger<MigrateEncodingOptions> _logger;
 17
 18    /// <summary>
 19    /// Initializes a new instance of the <see cref="MigrateEncodingOptions"/> class.
 20    /// </summary>
 21    /// <param name="applicationPaths">An instance of <see cref="ServerApplicationPaths"/>.</param>
 22    /// <param name="loggerFactory">An instance of the <see cref="ILoggerFactory"/> interface.</param>
 23    public MigrateEncodingOptions(ServerApplicationPaths applicationPaths, ILoggerFactory loggerFactory)
 24    {
 025        _applicationPaths = applicationPaths;
 026        _logger = loggerFactory.CreateLogger<MigrateEncodingOptions>();
 027    }
 28
 29    /// <inheritdoc />
 030    public Guid Id => Guid.Parse("A8E61960-7726-4450-8F3D-82C12DAABBCB");
 31
 32    /// <inheritdoc />
 033    public string Name => nameof(MigrateEncodingOptions);
 34
 35    /// <inheritdoc />
 036    public bool PerformOnNewInstall => false;
 37
 38    /// <inheritdoc />
 39    public void Perform()
 40    {
 041        string path = Path.Combine(_applicationPaths.ConfigurationDirectoryPath, "encoding.xml");
 042        var oldSerializer = new XmlSerializer(typeof(OldEncodingOptions), new XmlRootAttribute("EncodingOptions"));
 043        OldEncodingOptions? oldConfig = null;
 44
 45        try
 46        {
 047            using var xmlReader = XmlReader.Create(path);
 048            oldConfig = (OldEncodingOptions?)oldSerializer.Deserialize(xmlReader);
 049        }
 050        catch (InvalidOperationException ex)
 51        {
 052            _logger.LogError(ex, "Migrate EncodingOptions deserialize Invalid Operation error");
 053        }
 054        catch (Exception ex)
 55        {
 056            _logger.LogError(ex, "Migrate EncodingOptions deserialize error");
 057        }
 58
 059        if (oldConfig is null)
 60        {
 061            return;
 62        }
 63
 064        var hardwareAccelerationType = HardwareAccelerationType.none;
 065        if (Enum.TryParse<HardwareAccelerationType>(oldConfig.HardwareAccelerationType, true, out var parsedHardwareAcce
 66        {
 067            hardwareAccelerationType = parsedHardwareAccelerationType;
 68        }
 69
 070        var tonemappingAlgorithm = TonemappingAlgorithm.none;
 071        if (Enum.TryParse<TonemappingAlgorithm>(oldConfig.TonemappingAlgorithm, true, out var parsedTonemappingAlgorithm
 72        {
 073            tonemappingAlgorithm = parsedTonemappingAlgorithm;
 74        }
 75
 076        var tonemappingMode = TonemappingMode.auto;
 077        if (Enum.TryParse<TonemappingMode>(oldConfig.TonemappingMode, true, out var parsedTonemappingMode))
 78        {
 079            tonemappingMode = parsedTonemappingMode;
 80        }
 81
 082        var tonemappingRange = TonemappingRange.auto;
 083        if (Enum.TryParse<TonemappingRange>(oldConfig.TonemappingRange, true, out var parsedTonemappingRange))
 84        {
 085            tonemappingRange = parsedTonemappingRange;
 86        }
 87
 088        var encoderPreset = EncoderPreset.superfast;
 089        if (Enum.TryParse<EncoderPreset>(oldConfig.TonemappingRange, true, out var parsedEncoderPreset))
 90        {
 091            encoderPreset = parsedEncoderPreset;
 92        }
 93
 094        var deinterlaceMethod = DeinterlaceMethod.yadif;
 095        if (Enum.TryParse<DeinterlaceMethod>(oldConfig.TonemappingRange, true, out var parsedDeinterlaceMethod))
 96        {
 097            deinterlaceMethod = parsedDeinterlaceMethod;
 98        }
 99
 0100        var encodingOptions = new EncodingOptions()
 0101        {
 0102            EncodingThreadCount = oldConfig.EncodingThreadCount,
 0103            TranscodingTempPath = oldConfig.TranscodingTempPath,
 0104            FallbackFontPath = oldConfig.FallbackFontPath,
 0105            EnableFallbackFont = oldConfig.EnableFallbackFont,
 0106            EnableAudioVbr = oldConfig.EnableAudioVbr,
 0107            DownMixAudioBoost = oldConfig.DownMixAudioBoost,
 0108            DownMixStereoAlgorithm = oldConfig.DownMixStereoAlgorithm,
 0109            MaxMuxingQueueSize = oldConfig.MaxMuxingQueueSize,
 0110            EnableThrottling = oldConfig.EnableThrottling,
 0111            ThrottleDelaySeconds = oldConfig.ThrottleDelaySeconds,
 0112            EnableSegmentDeletion = oldConfig.EnableSegmentDeletion,
 0113            SegmentKeepSeconds = oldConfig.SegmentKeepSeconds,
 0114            HardwareAccelerationType = hardwareAccelerationType,
 0115            EncoderAppPath = oldConfig.EncoderAppPath,
 0116            EncoderAppPathDisplay = oldConfig.EncoderAppPathDisplay,
 0117            VaapiDevice = oldConfig.VaapiDevice,
 0118            EnableTonemapping = oldConfig.EnableTonemapping,
 0119            EnableVppTonemapping = oldConfig.EnableVppTonemapping,
 0120            EnableVideoToolboxTonemapping = oldConfig.EnableVideoToolboxTonemapping,
 0121            TonemappingAlgorithm = tonemappingAlgorithm,
 0122            TonemappingMode = tonemappingMode,
 0123            TonemappingRange = tonemappingRange,
 0124            TonemappingDesat = oldConfig.TonemappingDesat,
 0125            TonemappingPeak = oldConfig.TonemappingPeak,
 0126            TonemappingParam = oldConfig.TonemappingParam,
 0127            VppTonemappingBrightness = oldConfig.VppTonemappingBrightness,
 0128            VppTonemappingContrast = oldConfig.VppTonemappingContrast,
 0129            H264Crf = oldConfig.H264Crf,
 0130            H265Crf = oldConfig.H265Crf,
 0131            EncoderPreset = encoderPreset,
 0132            DeinterlaceDoubleRate = oldConfig.DeinterlaceDoubleRate,
 0133            DeinterlaceMethod = deinterlaceMethod,
 0134            EnableDecodingColorDepth10Hevc = oldConfig.EnableDecodingColorDepth10Hevc,
 0135            EnableDecodingColorDepth10Vp9 = oldConfig.EnableDecodingColorDepth10Vp9,
 0136            EnableEnhancedNvdecDecoder = oldConfig.EnableEnhancedNvdecDecoder,
 0137            PreferSystemNativeHwDecoder = oldConfig.PreferSystemNativeHwDecoder,
 0138            EnableIntelLowPowerH264HwEncoder = oldConfig.EnableIntelLowPowerH264HwEncoder,
 0139            EnableIntelLowPowerHevcHwEncoder = oldConfig.EnableIntelLowPowerHevcHwEncoder,
 0140            EnableHardwareEncoding = oldConfig.EnableHardwareEncoding,
 0141            AllowHevcEncoding = oldConfig.AllowHevcEncoding,
 0142            AllowAv1Encoding = oldConfig.AllowAv1Encoding,
 0143            EnableSubtitleExtraction = oldConfig.EnableSubtitleExtraction,
 0144            HardwareDecodingCodecs = oldConfig.HardwareDecodingCodecs,
 0145            AllowOnDemandMetadataBasedKeyframeExtractionForExtensions = oldConfig.AllowOnDemandMetadataBasedKeyframeExtr
 0146        };
 147
 0148        var newSerializer = new XmlSerializer(typeof(EncodingOptions));
 0149        var xmlWriterSettings = new XmlWriterSettings { Indent = true };
 0150        using var xmlWriter = XmlWriter.Create(path, xmlWriterSettings);
 0151        newSerializer.Serialize(xmlWriter, encodingOptions);
 0152    }
 153
 154#pragma warning disable
 155    public sealed class OldEncodingOptions
 156    {
 157        public int EncodingThreadCount { get; set; }
 158
 159        public string TranscodingTempPath { get; set; }
 160
 161        public string FallbackFontPath { get; set; }
 162
 163        public bool EnableFallbackFont { get; set; }
 164
 165        public bool EnableAudioVbr { get; set; }
 166
 167        public double DownMixAudioBoost { get; set; }
 168
 169        public DownMixStereoAlgorithms DownMixStereoAlgorithm { get; set; }
 170
 171        public int MaxMuxingQueueSize { get; set; }
 172
 173        public bool EnableThrottling { get; set; }
 174
 175        public int ThrottleDelaySeconds { get; set; }
 176
 177        public bool EnableSegmentDeletion { get; set; }
 178
 179        public int SegmentKeepSeconds { get; set; }
 180
 181        public string HardwareAccelerationType { get; set; }
 182
 183        public string EncoderAppPath { get; set; }
 184
 185        public string EncoderAppPathDisplay { get; set; }
 186
 187        public string VaapiDevice { get; set; }
 188
 189        public bool EnableTonemapping { get; set; }
 190
 191        public bool EnableVppTonemapping { get; set; }
 192
 193        public bool EnableVideoToolboxTonemapping { get; set; }
 194
 195        public string TonemappingAlgorithm { get; set; }
 196
 197        public string TonemappingMode { get; set; }
 198
 199        public string TonemappingRange { get; set; }
 200
 201        public double TonemappingDesat { get; set; }
 202
 203        public double TonemappingPeak { get; set; }
 204
 205        public double TonemappingParam { get; set; }
 206
 207        public double VppTonemappingBrightness { get; set; }
 208
 209        public double VppTonemappingContrast { get; set; }
 210
 211        public int H264Crf { get; set; }
 212
 213        public int H265Crf { get; set; }
 214
 215        public string EncoderPreset { get; set; }
 216
 217        public bool DeinterlaceDoubleRate { get; set; }
 218
 219        public string DeinterlaceMethod { get; set; }
 220
 221        public bool EnableDecodingColorDepth10Hevc { get; set; }
 222
 223        public bool EnableDecodingColorDepth10Vp9 { get; set; }
 224
 225        public bool EnableEnhancedNvdecDecoder { get; set; }
 226
 227        public bool PreferSystemNativeHwDecoder { get; set; }
 228
 229        public bool EnableIntelLowPowerH264HwEncoder { get; set; }
 230
 231        public bool EnableIntelLowPowerHevcHwEncoder { get; set; }
 232
 233        public bool EnableHardwareEncoding { get; set; }
 234
 235        public bool AllowHevcEncoding { get; set; }
 236
 237        public bool AllowAv1Encoding { get; set; }
 238
 239        public bool EnableSubtitleExtraction { get; set; }
 240
 241        public string[] HardwareDecodingCodecs { get; set; }
 242
 243        public string[] AllowOnDemandMetadataBasedKeyframeExtractionForExtensions { get; set; }
 244    }
 245}
Generated by: ReportGenerator 5.3.8.0
9/19/2024 - 12:16:35 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Emby.Server.Implementations.ServerApplicationPaths,Microsoft.Extensions.Logging.ILoggerFactory)
get_Id()
get_Name()
get_PerformOnNewInstall()
Perform()