diff --git a/Emby.Photos/PhotoProvider.cs b/Emby.Photos/PhotoProvider.cs
index 99a635e60..1591609ab 100644
--- a/Emby.Photos/PhotoProvider.cs
+++ b/Emby.Photos/PhotoProvider.cs
@@ -170,8 +170,8 @@ namespace Emby.Photos
                 }
             }
 
-            const ItemUpdateType result = ItemUpdateType.ImageUpdate | ItemUpdateType.MetadataImport;
-            return Task.FromResult(result);
+            const ItemUpdateType Result = ItemUpdateType.ImageUpdate | ItemUpdateType.MetadataImport;
+            return Task.FromResult(Result);
         }
     }
 }
diff --git a/Emby.Server.Implementations/MediaEncoder/EncodingManager.cs b/Emby.Server.Implementations/MediaEncoder/EncodingManager.cs
index 52d07d784..840aca7a6 100644
--- a/Emby.Server.Implementations/MediaEncoder/EncodingManager.cs
+++ b/Emby.Server.Implementations/MediaEncoder/EncodingManager.cs
@@ -139,7 +139,7 @@ namespace Emby.Server.Implementations.MediaEncoder
 
                             var protocol = MediaProtocol.File;
 
-                            var inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, video.Path, protocol, null, Array.Empty<string>());
+                            var inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, video.Path, null, Array.Empty<string>());
 
                             Directory.CreateDirectory(Path.GetDirectoryName(path));
 
diff --git a/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs b/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
index 5665e72cf..963091673 100644
--- a/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
+++ b/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Model.Configuration;
@@ -22,8 +23,17 @@ namespace MediaBrowser.Controller.MediaEncoding
         private readonly IMediaEncoder _mediaEncoder;
         private readonly IFileSystem _fileSystem;
         private readonly ISubtitleEncoder _subtitleEncoder;
-        // private readonly IApplicationPaths _appPaths;
-        // private readonly IAssemblyInfo _assemblyInfo;
+
+        private static readonly string[] _videoProfiles = new[]
+        {
+            "ConstrainedBaseline",
+            "Baseline",
+            "Extended",
+            "Main",
+            "High",
+            "ProgressiveHigh",
+            "ConstrainedHigh"
+        };
 
         public EncodingHelper(IMediaEncoder mediaEncoder, IFileSystem fileSystem, ISubtitleEncoder subtitleEncoder)
         {
@@ -33,14 +43,10 @@ namespace MediaBrowser.Controller.MediaEncoding
         }
 
         public string GetH264Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
-        {
-            return GetH264OrH265Encoder("libx264", "h264", state, encodingOptions);
-        }
+            => GetH264OrH265Encoder("libx264", "h264", state, encodingOptions);
 
         public string GetH265Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
-        {
-            return GetH264OrH265Encoder("libx265", "hevc", state, encodingOptions);
-        }
+            => GetH264OrH265Encoder("libx265", "hevc", state, encodingOptions);
 
         private string GetH264OrH265Encoder(string defaultEncoder, string hwEncoder, EncodingJobInfo state, EncodingOptions encodingOptions)
         {
@@ -64,19 +70,17 @@ namespace MediaBrowser.Controller.MediaEncoding
                 };
 
                 if (!string.IsNullOrEmpty(hwType)
-                    && encodingOptions.EnableHardwareEncoding && codecMap.ContainsKey(hwType))
+                    && encodingOptions.EnableHardwareEncoding
+                    && codecMap.ContainsKey(hwType)
+                    && CheckVaapi(state, hwType, encodingOptions))
                 {
-                    if (CheckVaapi(state, hwType, encodingOptions))
-                    {
-                        var preferredEncoder = codecMap[hwType];
+                    var preferredEncoder = codecMap[hwType];
 
-                        if (_mediaEncoder.SupportsEncoder(preferredEncoder))
-                        {
-                            return preferredEncoder;
-                        }
+                    if (_mediaEncoder.SupportsEncoder(preferredEncoder))
+                    {
+                        return preferredEncoder;
                     }
                 }
-
             }
 
             // Avoid performing a second attempt when the first one
@@ -106,15 +110,13 @@ namespace MediaBrowser.Controller.MediaEncoding
         {
             var videoStream = state.VideoStream;
 
-            if (videoStream != null)
+            // vaapi will throw an error with this input
+            // [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.
+            if (string.Equals(videoStream?.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))
             {
-                // vaapi will throw an error with this input
-                // [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.
-                if (string.Equals(videoStream.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))
-                {
-                    return false;
-                }
+                return false;
             }
+
             return true;
         }
 
@@ -127,23 +129,27 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (!string.IsNullOrEmpty(codec))
             {
-                if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase) ||
-                    string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase))
+                if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase))
                 {
                     return GetH265Encoder(state, encodingOptions);
                 }
+
                 if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))
                 {
                     return GetH264Encoder(state, encodingOptions);
                 }
+
                 if (string.Equals(codec, "vpx", StringComparison.OrdinalIgnoreCase))
                 {
                     return "libvpx";
                 }
+
                 if (string.Equals(codec, "wmv", StringComparison.OrdinalIgnoreCase))
                 {
                     return "wmv2";
                 }
+
                 if (string.Equals(codec, "theora", StringComparison.OrdinalIgnoreCase))
                 {
                     return "libtheora";
@@ -162,9 +168,7 @@ namespace MediaBrowser.Controller.MediaEncoding
         /// <returns>System.String.</returns>
         public string GetUserAgentParam(EncodingJobInfo state)
         {
-            string useragent = null;
-
-            state.RemoteHttpHeaders.TryGetValue("User-Agent", out useragent);
+            state.RemoteHttpHeaders.TryGetValue("User-Agent", out string useragent);
 
             if (!string.IsNullOrEmpty(useragent))
             {
@@ -193,50 +197,62 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return null;
             }
+
             if (string.Equals(container, "wmv", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "mts", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "vob", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "mpg", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "mpeg", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "rec", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "dvr-ms", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "ogm", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "divx", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "tp", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "rmvb", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(container, "rtp", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
@@ -264,10 +280,12 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return null;
             }
+
             if (string.Equals(codec, "aac_latm", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
             }
+
             if (string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))
             {
                 return null;
@@ -292,30 +310,37 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return "mp3";
             }
+
             if (string.Equals(ext, ".aac", StringComparison.OrdinalIgnoreCase))
             {
                 return "aac";
             }
+
             if (string.Equals(ext, ".wma", StringComparison.OrdinalIgnoreCase))
             {
                 return "wma";
             }
+
             if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase))
             {
                 return "vorbis";
             }
+
             if (string.Equals(ext, ".oga", StringComparison.OrdinalIgnoreCase))
             {
                 return "vorbis";
             }
+
             if (string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
             {
                 return "vorbis";
             }
+
             if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
             {
                 return "vorbis";
             }
+
             if (string.Equals(ext, ".webma", StringComparison.OrdinalIgnoreCase))
             {
                 return "vorbis";
@@ -337,14 +362,17 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return "wmv";
             }
+
             if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
             {
                 return "vpx";
             }
+
             if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
             {
                 return "theora";
             }
+
             if (string.Equals(ext, ".m3u8", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ts", StringComparison.OrdinalIgnoreCase))
             {
                 return "h264";
@@ -355,19 +383,9 @@ namespace MediaBrowser.Controller.MediaEncoding
 
         public int GetVideoProfileScore(string profile)
         {
-            var list = new[]
-            {
-                "ConstrainedBaseline",
-                "Baseline",
-                "Extended",
-                "Main",
-                "High",
-                "ProgressiveHigh",
-                "ConstrainedHigh"
-            };
-
             // strip spaces because they may be stripped out on the query string
-            return Array.FindIndex(list, t => string.Equals(t, profile.Replace(" ", ""), StringComparison.OrdinalIgnoreCase));
+            profile = profile.Replace(" ", "");
+            return Array.FindIndex(_videoProfiles, x => string.Equals(x, profile, StringComparison.OrdinalIgnoreCase));
         }
 
         public string GetInputPathArgument(EncodingJobInfo state)
@@ -375,14 +393,19 @@ namespace MediaBrowser.Controller.MediaEncoding
             var protocol = state.InputProtocol;
             var mediaPath = state.MediaPath ?? string.Empty;
 
-            var inputPath = new[] { mediaPath };
-
-            if (state.IsInputVideo)
+            string[] inputPath;
+            if (state.IsInputVideo
+                && !(state.VideoType == VideoType.Iso && state.IsoMount == null))
             {
-                if (!(state.VideoType == VideoType.Iso && state.IsoMount == null))
-                {
-                    inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, mediaPath, state.InputProtocol, state.IsoMount, state.PlayableStreamFileNames);
-                }
+                inputPath = MediaEncoderHelpers.GetInputArgument(
+                    _fileSystem,
+                    mediaPath,
+                    state.IsoMount,
+                    state.PlayableStreamFileNames);
+            }
+            else
+            {
+                inputPath = new[] { mediaPath };
             }
 
             return _mediaEncoder.GetInputArgument(inputPath, protocol);
@@ -401,18 +424,22 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return "aac -strict experimental";
             }
+
             if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
             {
                 return "libmp3lame";
             }
+
             if (string.Equals(codec, "vorbis", StringComparison.OrdinalIgnoreCase))
             {
                 return "libvorbis";
             }
+
             if (string.Equals(codec, "wma", StringComparison.OrdinalIgnoreCase))
             {
                 return "wmav2";
             }
+
             if (string.Equals(codec, "opus", StringComparison.OrdinalIgnoreCase))
             {
                 return "libopus";
@@ -426,54 +453,59 @@ namespace MediaBrowser.Controller.MediaEncoding
         /// </summary>
         public string GetInputArgument(EncodingJobInfo state, EncodingOptions encodingOptions)
         {
-            var request = state.BaseRequest;
+            var arg = new StringBuilder();
 
-            var arg = string.Format("-i {0}", GetInputPathArgument(state));
-
-            if (state.SubtitleStream != null && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
+            if (state.IsVideoRequest
+                && string.Equals(encodingOptions.HardwareAccelerationType, "vaapi", StringComparison.OrdinalIgnoreCase))
             {
-                if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
+                var hasGraphicalSubs = state.SubtitleStream != null && !state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode;
+                var hwOutputFormat = "vaapi";
+
+                if (hasGraphicalSubs)
                 {
-                    if (state.VideoStream != null && state.VideoStream.Width.HasValue)
-                    {
-                        // This is hacky but not sure how to get the exact subtitle resolution
-                        int height = Convert.ToInt32((double)state.VideoStream.Width.Value / 16.0 * 9.0);
-
-                        arg += string.Format(" -canvas_size {0}:{1}", state.VideoStream.Width.Value.ToString(CultureInfo.InvariantCulture), height.ToString(CultureInfo.InvariantCulture));
-                    }
-
-                    var subtitlePath = state.SubtitleStream.Path;
-
-                    if (string.Equals(Path.GetExtension(subtitlePath), ".sub", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var idxFile = Path.ChangeExtension(subtitlePath, ".idx");
-                        if (File.Exists(idxFile))
-                        {
-                            subtitlePath = idxFile;
-                        }
-                    }
-
-                    arg += " -i \"" + subtitlePath + "\"";
+                    hwOutputFormat = "yuv420p";
                 }
+
+                arg.Append("-hwaccel vaapi -hwaccel_output_format ")
+                    .Append(hwOutputFormat)
+                    .Append(" -vaapi_device ")
+                    .Append(encodingOptions.VaapiDevice)
+                    .Append(' ');
             }
 
-            if (state.IsVideoRequest)
+            arg.Append("-i ")
+                .Append(GetInputPathArgument(state));
+
+            if (state.SubtitleStream != null
+                && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode
+                && state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
             {
-                if (string.Equals(encodingOptions.HardwareAccelerationType, "vaapi", StringComparison.OrdinalIgnoreCase))
+                if (state.VideoStream != null && state.VideoStream.Width.HasValue)
                 {
-                    var hasGraphicalSubs = state.SubtitleStream != null && !state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode;
-                    var hwOutputFormat = "vaapi";
+                    // This is hacky but not sure how to get the exact subtitle resolution
+                    int height = Convert.ToInt32(state.VideoStream.Width.Value / 16.0 * 9.0);
 
-                    if (hasGraphicalSubs)
-                    {
-                        hwOutputFormat = "yuv420p";
-                    }
-
-                    arg = "-hwaccel vaapi -hwaccel_output_format " + hwOutputFormat + " -vaapi_device " + encodingOptions.VaapiDevice + " " + arg;
+                    arg.Append(" -canvas_size ")
+                        .Append(state.VideoStream.Width.Value.ToString(CultureInfo.InvariantCulture))
+                        .Append(':')
+                        .Append(height.ToString(CultureInfo.InvariantCulture));
                 }
+
+                var subtitlePath = state.SubtitleStream.Path;
+
+                if (string.Equals(Path.GetExtension(subtitlePath), ".sub", StringComparison.OrdinalIgnoreCase))
+                {
+                    var idxFile = Path.ChangeExtension(subtitlePath, ".idx");
+                    if (File.Exists(idxFile))
+                    {
+                        subtitlePath = idxFile;
+                    }
+                }
+
+                arg.Append(" -i \"").Append(subtitlePath).Append('\"');
             }
 
-            return arg.Trim();
+            return arg.ToString();
         }
 
         /// <summary>
@@ -485,16 +517,16 @@ namespace MediaBrowser.Controller.MediaEncoding
         {
             var codec = stream.Codec ?? string.Empty;
 
-            return codec.IndexOf("264", StringComparison.OrdinalIgnoreCase) != -1 ||
-                   codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1;
+            return codec.IndexOf("264", StringComparison.OrdinalIgnoreCase) != -1
+                    || codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1;
         }
 
         public bool IsH265(MediaStream stream)
         {
             var codec = stream.Codec ?? string.Empty;
 
-            return codec.IndexOf("265", StringComparison.OrdinalIgnoreCase) != -1 ||
-                   codec.IndexOf("hevc", StringComparison.OrdinalIgnoreCase) != -1;
+            return codec.IndexOf("265", StringComparison.OrdinalIgnoreCase) != -1
+                || codec.IndexOf("hevc", StringComparison.OrdinalIgnoreCase) != -1;
         }
 
         public string GetBitStreamArgs(MediaStream stream)
@@ -523,27 +555,38 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     // With vpx when crf is used, b:v becomes a max rate
                     // https://trac.ffmpeg.org/wiki/vpxEncodingGuide.
-                    return string.Format(" -maxrate:v {0} -bufsize:v {1} -b:v {0}", bitrate.Value.ToString(_usCulture), (bitrate.Value * 2).ToString(_usCulture));
+                    return string.Format(
+                        CultureInfo.InvariantCulture,
+                        " -maxrate:v {0} -bufsize:v {1} -b:v {0}",
+                        bitrate.Value,
+                        bitrate.Value * 2);
                 }
 
                 if (string.Equals(videoCodec, "msmpeg4", StringComparison.OrdinalIgnoreCase))
                 {
-                    return string.Format(" -b:v {0}", bitrate.Value.ToString(_usCulture));
+                    return string.Format(
+                        CultureInfo.InvariantCulture,
+                        " -b:v {0}",
+                        bitrate.Value);
                 }
 
                 if (string.Equals(videoCodec, "libx264", StringComparison.OrdinalIgnoreCase) ||
                     string.Equals(videoCodec, "libx265", StringComparison.OrdinalIgnoreCase))
                 {
                     // h264
-                    return string.Format(" -maxrate {0} -bufsize {1}",
-                        bitrate.Value.ToString(_usCulture),
-                        (bitrate.Value * 2).ToString(_usCulture));
+                    return string.Format(
+                        CultureInfo.InvariantCulture,
+                        " -maxrate {0} -bufsize {1}",
+                        bitrate.Value,
+                        bitrate.Value * 2);
                 }
 
                 // h264
-                return string.Format(" -b:v {0} -maxrate {0} -bufsize {1}",
-                    bitrate.Value.ToString(_usCulture),
-                    (bitrate.Value * 2).ToString(_usCulture));
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    " -b:v {0} -maxrate {0} -bufsize {1}",
+                    bitrate.Value,
+                    bitrate.Value * 2);
             }
 
             return string.Empty;
@@ -576,7 +619,7 @@ namespace MediaBrowser.Controller.MediaEncoding
             // hls always copies timestamps
             var setPtsParam = state.CopyTimestamps || state.TranscodingType != TranscodingJobType.Progressive
                 ? string.Empty
-                : string.Format(",setpts=PTS -{0}/TB", seconds.ToString(_usCulture));
+                : string.Format(CultureInfo.InvariantCulture, ",setpts=PTS -{0}/TB", seconds);
 
             // TODO
             // var fallbackFontPath = Path.Combine(_appPaths.ProgramDataPath, "fonts", "DroidSansFallback.ttf");
@@ -684,6 +727,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     encodeCrf = encodingOptions.H265Crf;
                 }
+
                 if (encodeCrf >= 0 && encodeCrf <= 51)
                 {
                     param += " -crf " + encodeCrf.ToString(CultureInfo.InvariantCulture);
@@ -695,12 +739,11 @@ namespace MediaBrowser.Controller.MediaEncoding
                     {
                         defaultCrf = "28";
                     }
+
                     param += " -crf " + defaultCrf;
                 }
             }
-
-            // h264 (h264_qsv)
-            else if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)) // h264 (h264_qsv)
             {
                 string[] valid_h264_qsv = { "veryslow", "slower", "slow", "medium", "fast", "faster", "veryfast" };
 
@@ -716,10 +759,8 @@ namespace MediaBrowser.Controller.MediaEncoding
                 param += " -look_ahead 0";
 
             }
-
-            // h264 (h264_nvenc)
-            else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase) ||
-                     string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase) // h264 (h264_nvenc)
+                || string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase))
             {
                 switch (encodingOptions.EncoderPreset)
                 {
@@ -750,9 +791,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                         break;
                 }
             }
-
-            // webm
-            else if (string.Equals(videoEncoder, "libvpx", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(videoEncoder, "libvpx", StringComparison.OrdinalIgnoreCase)) // webm
             {
                 // Values 0-3, 0 being highest quality but slower
                 var profileScore = 0;
@@ -778,18 +817,14 @@ namespace MediaBrowser.Controller.MediaEncoding
                     qmin,
                     qmax);
             }
-
             else if (string.Equals(videoEncoder, "mpeg4", StringComparison.OrdinalIgnoreCase))
             {
                 param += "-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2";
             }
-
-            // asf/wmv
-            else if (string.Equals(videoEncoder, "wmv2", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(videoEncoder, "wmv2", StringComparison.OrdinalIgnoreCase)) // asf/wmv
             {
                 param += "-qmin 2";
             }
-
             else if (string.Equals(videoEncoder, "msmpeg4", StringComparison.OrdinalIgnoreCase))
             {
                 param += "-mbd 2";
@@ -805,21 +840,21 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             var targetVideoCodec = state.ActualOutputVideoCodec;
 
-            var request = state.BaseRequest;
             var profile = state.GetRequestedProfiles(targetVideoCodec).FirstOrDefault();
 
             // vaapi does not support Baseline profile, force Constrained Baseline in this case,
             // which is compatible (and ugly)
-            if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) &&
-                profile != null && profile.ToLowerInvariant().Contains("baseline"))
+            if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
+                && profile != null
+                && profile.IndexOf("baseline", StringComparison.OrdinalIgnoreCase) != -1)
             {
-                    profile = "constrained_baseline";
+                profile = "constrained_baseline";
             }
 
             if (!string.IsNullOrEmpty(profile))
             {
-                if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase) &&
-                    !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
+                if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase)
+                    && !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
                 {
                     // not supported by h264_omx
                     param += " -profile:v " + profile;
@@ -834,9 +869,9 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                 // h264_qsv and h264_nvenc expect levels to be expressed as a decimal. libx264 supports decimal and non-decimal format
                 // also needed for libx264 due to https://trac.ffmpeg.org/ticket/3307
-                if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) ||
-                    string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase) ||
-                    string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))
+                if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))
                 {
                     switch (level)
                     {
@@ -872,11 +907,11 @@ namespace MediaBrowser.Controller.MediaEncoding
                             break;
                     }
                 }
-                // nvenc doesn't decode with param -level set ?!
-                else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase) ||
-                         string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase))
+                else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase))
                 {
-                    // todo param += ""; 
+                    // nvenc doesn't decode with param -level set ?!
+                    // TODO:
                 }
                 else if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase))
                 {
@@ -894,10 +929,10 @@ namespace MediaBrowser.Controller.MediaEncoding
                 // todo
             }
 
-            if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase) &&
-                !string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) &&
-                !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) &&
-                !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
+            if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
             {
                 param = "-pix_fmt yuv420p " + param;
             }
@@ -919,12 +954,10 @@ namespace MediaBrowser.Controller.MediaEncoding
                 return false;
             }
 
-            if (videoStream.IsInterlaced)
+            if (videoStream.IsInterlaced
+                && state.DeInterlace(videoStream.Codec, false))
             {
-                if (state.DeInterlace(videoStream.Codec, false))
-                {
-                    return false;
-                }
+                return false;
             }
 
             if (videoStream.IsAnamorphic ?? false)
@@ -936,24 +969,23 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
 
             // Can't stream copy if we're burning in subtitles
-            if (request.SubtitleStreamIndex.HasValue)
+            if (request.SubtitleStreamIndex.HasValue
+                && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
             {
-                if (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
-                {
-                    return false;
-                }
+                return false;
             }
 
-            if (string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
+            if (string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
+                && videoStream.IsAVC.HasValue
+                && !videoStream.IsAVC.Value
+                && request.RequireAvc)
             {
-                if (videoStream.IsAVC.HasValue && !videoStream.IsAVC.Value && request.RequireAvc)
-                {
-                    return false;
-                }
+                return false;
             }
 
             // Source and target codecs must match
-            if (string.IsNullOrEmpty(videoStream.Codec) || !state.SupportedVideoCodecs.Contains(videoStream.Codec, StringComparer.OrdinalIgnoreCase))
+            if (string.IsNullOrEmpty(videoStream.Codec)
+                || !state.SupportedVideoCodecs.Contains(videoStream.Codec, StringComparer.OrdinalIgnoreCase))
             {
                 return false;
             }
@@ -983,21 +1015,17 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
 
             // Video width must fall within requested value
-            if (request.MaxWidth.HasValue)
+            if (request.MaxWidth.HasValue
+                && (!videoStream.Width.HasValue || videoStream.Width.Value > request.MaxWidth.Value))
             {
-                if (!videoStream.Width.HasValue || videoStream.Width.Value > request.MaxWidth.Value)
-                {
-                    return false;
-                }
+                return false;
             }
 
             // Video height must fall within requested value
-            if (request.MaxHeight.HasValue)
+            if (request.MaxHeight.HasValue
+                && (!videoStream.Height.HasValue || videoStream.Height.Value > request.MaxHeight.Value))
             {
-                if (!videoStream.Height.HasValue || videoStream.Height.Value > request.MaxHeight.Value)
-                {
-                    return false;
-                }
+                return false;
             }
 
             // Video framerate must fall within requested value
@@ -1013,12 +1041,10 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
 
             // Video bitrate must fall within requested value
-            if (request.VideoBitRate.HasValue)
+            if (request.VideoBitRate.HasValue
+                && (!videoStream.BitRate.HasValue || videoStream.BitRate.Value > request.VideoBitRate.Value))
             {
-                if (!videoStream.BitRate.HasValue || videoStream.BitRate.Value > request.VideoBitRate.Value)
-                {
-                    return false;
-                }
+                return false;
             }
 
             var maxBitDepth = state.GetRequestedVideoBitDepth(videoStream.Codec);
@@ -1031,35 +1057,31 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
 
             var maxRefFrames = state.GetRequestedMaxRefFrames(videoStream.Codec);
-            if (maxRefFrames.HasValue)
+            if (maxRefFrames.HasValue
+                && videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > maxRefFrames.Value)
             {
-                if (videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > maxRefFrames.Value)
+                return false;
+            }
+
+            // If a specific level was requested, the source must match or be less than
+            var level = state.GetRequestedLevel(videoStream.Codec);
+            if (!string.IsNullOrEmpty(level)
+                && double.TryParse(level, NumberStyles.Any, _usCulture, out var requestLevel))
+            {
+                if (!videoStream.Level.HasValue)
+                {
+                    //return false;
+                }
+
+                if (videoStream.Level.HasValue && videoStream.Level.Value > requestLevel)
                 {
                     return false;
                 }
             }
 
-            // If a specific level was requested, the source must match or be less than
-            var level = state.GetRequestedLevel(videoStream.Codec);
-            if (!string.IsNullOrEmpty(level))
-            {
-                if (double.TryParse(level, NumberStyles.Any, _usCulture, out var requestLevel))
-                {
-                    if (!videoStream.Level.HasValue)
-                    {
-                        //return false;
-                    }
-
-                    if (videoStream.Level.HasValue && videoStream.Level.Value > requestLevel)
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            if (string.Equals(state.InputContainer, "avi", StringComparison.OrdinalIgnoreCase) &&
-                string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase) &&
-                !(videoStream.IsAVC ?? false))
+            if (string.Equals(state.InputContainer, "avi", StringComparison.OrdinalIgnoreCase)
+                && string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase)
+                && !(videoStream.IsAVC ?? false))
             {
                 // see Coach S01E01 - Kelly and the Professor(0).avi
                 return false;
@@ -1068,7 +1090,7 @@ namespace MediaBrowser.Controller.MediaEncoding
             return request.EnableAutoStreamCopy;
         }
 
-        public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, string[] supportedAudioCodecs)
+        public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, IEnumerable<string> supportedAudioCodecs)
         {
             var request = state.BaseRequest;
 
@@ -1078,16 +1100,16 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
 
             var maxBitDepth = state.GetRequestedAudioBitDepth(audioStream.Codec);
-            if (maxBitDepth.HasValue)
+            if (maxBitDepth.HasValue
+                && audioStream.BitDepth.HasValue
+                && audioStream.BitDepth.Value > maxBitDepth.Value)
             {
-                if (audioStream.BitDepth.HasValue && audioStream.BitDepth.Value > maxBitDepth.Value)
-                {
-                    return false;
-                }
+                return false;
             }
 
             // Source and target codecs must match
-            if (string.IsNullOrEmpty(audioStream.Codec) || !supportedAudioCodecs.Contains(audioStream.Codec, StringComparer.OrdinalIgnoreCase))
+            if (string.IsNullOrEmpty(audioStream.Codec)
+                || !supportedAudioCodecs.Contains(audioStream.Codec, StringComparer.OrdinalIgnoreCase))
             {
                 return false;
             }
@@ -1100,6 +1122,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     return false;
                 }
+
                 if (audioStream.Channels.Value > channels.Value)
                 {
                     return false;
@@ -1113,6 +1136,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     return false;
                 }
+
                 if (audioStream.SampleRate.Value > request.AudioSampleRate.Value)
                 {
                     return false;
@@ -1126,6 +1150,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     return false;
                 }
+
                 if (audioStream.BitRate.Value > request.AudioBitRate.Value)
                 {
                     return false;
@@ -1141,17 +1166,17 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (videoStream != null)
             {
-                var isUpscaling = request.Height.HasValue && videoStream.Height.HasValue &&
-                    request.Height.Value > videoStream.Height.Value && request.Width.HasValue && videoStream.Width.HasValue &&
-                    request.Width.Value > videoStream.Width.Value;
+                var isUpscaling = request.Height.HasValue
+                    && videoStream.Height.HasValue
+                    && request.Height.Value > videoStream.Height.Value
+                    && request.Width.HasValue
+                    && videoStream.Width.HasValue
+                    && request.Width.Value > videoStream.Width.Value;
 
                 // Don't allow bitrate increases unless upscaling
-                if (!isUpscaling)
+                if (!isUpscaling && bitrate.HasValue && videoStream.BitRate.HasValue)
                 {
-                    if (bitrate.HasValue && videoStream.BitRate.HasValue)
-                    {
-                        bitrate = GetMinBitrate(videoStream.BitRate.Value, bitrate.Value);
-                    }
+                    bitrate = GetMinBitrate(videoStream.BitRate.Value, bitrate.Value);
                 }
             }
 
@@ -1179,7 +1204,7 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
             else if (sourceBitrate <= 3000000)
             {
-                sourceBitrate = Convert.ToInt32(sourceBitrate * 2);
+                sourceBitrate *= 2;
             }
 
             var bitrate = Math.Min(sourceBitrate, requestedBitrate);
@@ -1189,12 +1214,13 @@ namespace MediaBrowser.Controller.MediaEncoding
 
         private static double GetVideoBitrateScaleFactor(string codec)
         {
-            if (StringHelper.EqualsIgnoreCase(codec, "h265") ||
-                StringHelper.EqualsIgnoreCase(codec, "hevc") ||
-                StringHelper.EqualsIgnoreCase(codec, "vp9"))
+            if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(codec, "vp9", StringComparison.OrdinalIgnoreCase))
             {
                 return .5;
             }
+
             return 1;
         }
 
@@ -1221,9 +1247,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 scaleFactor = Math.Max(scaleFactor, 2);
             }
 
-            var newBitrate = scaleFactor * bitrate;
-
-            return Convert.ToInt32(newBitrate);
+            return Convert.ToInt32(scaleFactor * bitrate);
         }
 
         public int? GetAudioBitrateParam(BaseEncodingJobOptions request, MediaStream audioStream)
@@ -1235,7 +1259,6 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                 // Don't encode any higher than this
                 return Math.Min(384000, request.AudioBitRate.Value);
-                //return Math.Min(currentBitrate, request.AudioBitRate.Value);
             }
 
             return null;
@@ -1248,12 +1271,14 @@ namespace MediaBrowser.Controller.MediaEncoding
             var filters = new List<string>();
 
             // Boost volume to 200% when downsampling from 6ch to 2ch
-            if (channels.HasValue && channels.Value <= 2)
+            if (channels.HasValue
+                && channels.Value <= 2
+                && state.AudioStream != null
+                && state.AudioStream.Channels.HasValue
+                && state.AudioStream.Channels.Value > 5
+                && !encodingOptions.DownMixAudioBoost.Equals(1))
             {
-                if (state.AudioStream != null && state.AudioStream.Channels.HasValue && state.AudioStream.Channels.Value > 5 && !encodingOptions.DownMixAudioBoost.Equals(1))
-                {
-                    filters.Add("volume=" + encodingOptions.DownMixAudioBoost.ToString(_usCulture));
-                }
+                filters.Add("volume=" + encodingOptions.DownMixAudioBoost.ToString(_usCulture));
             }
 
             var isCopyingTimestamps = state.CopyTimestamps || state.TranscodingType != TranscodingJobType.Progressive;
@@ -1261,12 +1286,16 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 var seconds = TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds;
 
-                filters.Add(string.Format("asetpts=PTS-{0}/TB", Math.Round(seconds).ToString(_usCulture)));
+                filters.Add(
+                    string.Format(
+                        CultureInfo.InvariantCulture,
+                        "asetpts=PTS-{0}/TB",
+                        Math.Round(seconds)));
             }
 
             if (filters.Count > 0)
             {
-                return "-af \"" + string.Join(",", filters.ToArray()) + "\"";
+                return "-af \"" + string.Join(",", filters) + "\"";
             }
 
             return string.Empty;
@@ -1283,18 +1312,17 @@ namespace MediaBrowser.Controller.MediaEncoding
         {
             var request = state.BaseRequest;
 
-            var inputChannels = audioStream == null
-                ? null
-                : audioStream.Channels;
+            var inputChannels = audioStream?.Channels;
 
             if (inputChannels <= 0)
             {
                 inputChannels = null;
             }
 
-            int? transcoderChannelLimit = null;
             var codec = outputAudioCodec ?? string.Empty;
 
+
+            int? transcoderChannelLimit;
             if (codec.IndexOf("wma", StringComparison.OrdinalIgnoreCase) != -1)
             {
                 // wmav2 currently only supports two channel output
@@ -1343,6 +1371,7 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 return val2;
             }
+
             if (!val2.HasValue)
             {
                 return val1;
@@ -1416,7 +1445,10 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (state.VideoStream != null)
             {
-                args += string.Format("-map 0:{0}", state.VideoStream.Index);
+                args += string.Format(
+                    CultureInfo.InvariantCulture,
+                    "-map 0:{0}",
+                    state.VideoStream.Index);
             }
             else
             {
@@ -1426,7 +1458,10 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (state.AudioStream != null)
             {
-                args += string.Format(" -map 0:{0}", state.AudioStream.Index);
+                args += string.Format(
+                    CultureInfo.InvariantCulture,
+                    " -map 0:{0}",
+                    state.AudioStream.Index);
             }
 
             else
@@ -1441,7 +1476,10 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
             else if (subtitleMethod == SubtitleDeliveryMethod.Embed)
             {
-                args += string.Format(" -map 0:{0}", state.SubtitleStream.Index);
+                args += string.Format(
+                    CultureInfo.InvariantCulture,
+                    " -map 0:{0}",
+                    state.SubtitleStream.Index);
             }
             else if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
             {
@@ -1493,7 +1531,10 @@ namespace MediaBrowser.Controller.MediaEncoding
             var request = state.BaseRequest;
 
             // Add resolution params, if specified
-            if (request.Width.HasValue || request.Height.HasValue || request.MaxHeight.HasValue || request.MaxWidth.HasValue)
+            if (request.Width.HasValue
+                || request.Height.HasValue
+                || request.MaxHeight.HasValue
+                || request.MaxWidth.HasValue)
             {
                 outputSizeParam = GetOutputSizeParam(state, options, outputVideoCodec).TrimEnd('"');
 
@@ -1515,12 +1556,15 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
-            if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase) && outputSizeParam.Length == 0)
+            if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
+                && outputSizeParam.Length == 0)
             {
                 outputSizeParam = ",format=nv12|vaapi,hwupload";
 
                 // Add parameters to use VAAPI with burn-in subttiles (GH issue #642)
-                if (state.SubtitleStream != null && state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode) {
+                if (state.SubtitleStream != null
+                    && state.SubtitleStream.IsTextSubtitleStream
+                    && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode) {
                     outputSizeParam += ",hwmap=mode=read+write+direct";
                 }
             }
@@ -1529,7 +1573,11 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (state.VideoStream != null && state.VideoStream.Width.HasValue && state.VideoStream.Height.HasValue)
             {
-                videoSizeParam = string.Format("scale={0}:{1}", state.VideoStream.Width.Value.ToString(_usCulture), state.VideoStream.Height.Value.ToString(_usCulture));
+                videoSizeParam = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "scale={0}:{1}",
+                    state.VideoStream.Width.Value,
+                    state.VideoStream.Height.Value);
 
                 videoSizeParam += ":force_original_aspect_ratio=decrease";
             }
@@ -1542,15 +1590,18 @@ namespace MediaBrowser.Controller.MediaEncoding
                 ? 0
                 : state.SubtitleStream.Index;
 
-            return string.Format(" -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}][sub]overlay{3}\"",
-                mapPrefix.ToString(_usCulture),
-                subtitleStreamIndex.ToString(_usCulture),
-                state.VideoStream.Index.ToString(_usCulture),
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                " -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}][sub]overlay{3}\"",
+                mapPrefix,
+                subtitleStreamIndex,
+                state.VideoStream.Index,
                 outputSizeParam,
                 videoSizeParam);
         }
 
-        private ValueTuple<int?, int?> GetFixedOutputSize(int? videoWidth,
+        private (int? width, int? height) GetFixedOutputSize(
+            int? videoWidth,
             int? videoHeight,
             int? requestedWidth,
             int? requestedHeight,
@@ -1559,11 +1610,11 @@ namespace MediaBrowser.Controller.MediaEncoding
         {
             if (!videoWidth.HasValue && !requestedWidth.HasValue)
             {
-                return new ValueTuple<int?, int?>(null, null);
+                return (null, null);
             }
             if (!videoHeight.HasValue && !requestedHeight.HasValue)
             {
-                return new ValueTuple<int?, int?>(null, null);
+                return (null, null);
             }
 
             decimal inputWidth = Convert.ToDecimal(videoWidth ?? requestedWidth);
@@ -1583,7 +1634,7 @@ namespace MediaBrowser.Controller.MediaEncoding
             outputWidth = 2 * Math.Truncate(outputWidth / 2);
             outputHeight = 2 * Math.Truncate(outputHeight / 2);
 
-            return new ValueTuple<int?, int?>(Convert.ToInt32(outputWidth), Convert.ToInt32(outputHeight));
+            return (Convert.ToInt32(outputWidth), Convert.ToInt32(outputHeight));
         }
 
         public List<string> GetScalingFilters(int? videoWidth,
@@ -1597,9 +1648,17 @@ namespace MediaBrowser.Controller.MediaEncoding
             int? requestedMaxHeight)
         {
             var filters = new List<string>();
-            var fixedOutputSize = GetFixedOutputSize(videoWidth, videoHeight, requestedWidth, requestedHeight, requestedMaxWidth, requestedMaxHeight);
+            var (width, height) = GetFixedOutputSize(
+                videoWidth,
+                videoHeight,
+                requestedWidth,
+                requestedHeight,
+                requestedMaxWidth,
+                requestedMaxHeight);
 
-            if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) && fixedOutputSize.Item1.HasValue && fixedOutputSize.Item2.HasValue)
+            if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
+                && width.HasValue
+                && height.HasValue)
             {
                 // Work around vaapi's reduced scaling features
                 var scaler = "scale_vaapi";
@@ -1607,15 +1666,26 @@ namespace MediaBrowser.Controller.MediaEncoding
                 // Given the input dimensions (inputWidth, inputHeight), determine the output dimensions
                 // (outputWidth, outputHeight). The user may request precise output dimensions or maximum
                 // output dimensions. Output dimensions are guaranteed to be even.
-                var outputWidth = fixedOutputSize.Item1.Value;
-                var outputHeight = fixedOutputSize.Item2.Value;
+                var outputWidth = width.Value;
+                var outputHeight = height.Value;
 
-                if (!videoWidth.HasValue || outputWidth != videoWidth.Value || !videoHeight.HasValue || outputHeight != videoHeight.Value)
+                if (!videoWidth.HasValue
+                    || outputWidth != videoWidth.Value
+                    || !videoHeight.HasValue
+                    || outputHeight != videoHeight.Value)
                 {
-                    filters.Add(string.Format("{0}=w={1}:h={2}", scaler, outputWidth.ToString(_usCulture), outputHeight.ToString(_usCulture)));
+                    filters.Add(
+                        string.Format(
+                            CultureInfo.InvariantCulture,
+                            "{0}=w={1}:h={2}",
+                            scaler,
+                            outputWidth,
+                            outputHeight));
                 }
             }
-            else if ((videoDecoder ?? string.Empty).IndexOf("_cuvid", StringComparison.OrdinalIgnoreCase) != -1 && fixedOutputSize.Item1.HasValue && fixedOutputSize.Item2.HasValue)
+            else if ((videoDecoder ?? string.Empty).IndexOf("_cuvid", StringComparison.OrdinalIgnoreCase) != -1
+                && width.HasValue
+                && height.HasValue)
             {
                 // Nothing to do, it's handled as an input resize filter
             }
@@ -1631,7 +1701,12 @@ namespace MediaBrowser.Controller.MediaEncoding
                         var widthParam = requestedWidth.Value.ToString(_usCulture);
                         var heightParam = requestedHeight.Value.ToString(_usCulture);
 
-                        filters.Add(string.Format("scale=trunc({0}/64)*64:trunc({1}/2)*2", widthParam, heightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc({0}/64)*64:trunc({1}/2)*2",
+                                widthParam,
+                                heightParam));
                     }
                     else
                     {
@@ -1647,11 +1722,21 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                     if (isExynosV4L2)
                     {
-                        filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/64)*64:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2", maxWidthParam, maxHeightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/64)*64:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2",
+                                maxWidthParam,
+                                maxHeightParam));
                     }
                     else
                     {
-                        filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/2)*2:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2", maxWidthParam, maxHeightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/2)*2:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2",
+                                maxWidthParam,
+                                maxHeightParam));
                     }
                 }
 
@@ -1667,7 +1752,11 @@ namespace MediaBrowser.Controller.MediaEncoding
                     {
                         var widthParam = requestedWidth.Value.ToString(_usCulture);
 
-                        filters.Add(string.Format("scale={0}:trunc(ow/a/2)*2", widthParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale={0}:trunc(ow/a/2)*2",
+                                widthParam));
                     }
                 }
 
@@ -1678,11 +1767,19 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                     if (isExynosV4L2)
                     {
-                        filters.Add(string.Format("scale=trunc(oh*a/64)*64:{0}", heightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(oh*a/64)*64:{0}",
+                                heightParam));
                     }
                     else
                     {
-                        filters.Add(string.Format("scale=trunc(oh*a/2)*2:{0}", heightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(oh*a/2)*2:{0}",
+                                heightParam));
                     }
                 }
 
@@ -1693,11 +1790,19 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                     if (isExynosV4L2)
                     {
-                        filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,{0})/64)*64:trunc(ow/dar/2)*2", maxWidthParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(min(max(iw\\,ih*dar)\\,{0})/64)*64:trunc(ow/dar/2)*2",
+                                maxWidthParam));
                     }
                     else
                     {
-                        filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,{0})/2)*2:trunc(ow/dar/2)*2", maxWidthParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(min(max(iw\\,ih*dar)\\,{0})/2)*2:trunc(ow/dar/2)*2",
+                                maxWidthParam));
                     }
                 }
 
@@ -1708,11 +1813,19 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                     if (isExynosV4L2)
                     {
-                        filters.Add(string.Format("scale=trunc(oh*a/64)*64:min(max(iw/dar\\,ih)\\,{0})", maxHeightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(oh*a/64)*64:min(max(iw/dar\\,ih)\\,{0})",
+                                maxHeightParam));
                     }
                     else
                     {
-                        filters.Add(string.Format("scale=trunc(oh*a/2)*2:min(max(iw/dar\\,ih)\\,{0})", maxHeightParam));
+                        filters.Add(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "scale=trunc(oh*a/2)*2:min(max(iw/dar\\,ih)\\,{0})",
+                                maxHeightParam));
                     }
                 }
             }
@@ -1722,8 +1835,8 @@ namespace MediaBrowser.Controller.MediaEncoding
 
         private string GetFixedSizeScalingFilter(Video3DFormat? threedFormat, int requestedWidth, int requestedHeight)
         {
-            var widthParam = requestedWidth.ToString(_usCulture);
-            var heightParam = requestedHeight.ToString(_usCulture);
+            var widthParam = requestedWidth.ToString(CultureInfo.InvariantCulture);
+            var heightParam = requestedHeight.ToString(CultureInfo.InvariantCulture);
 
             string filter = null;
 
@@ -1765,13 +1878,14 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
-            return string.Format(filter, widthParam, heightParam);
+            return string.Format(CultureInfo.InvariantCulture, filter, widthParam, heightParam);
         }
 
         /// <summary>
         /// If we're going to put a fixed size on the command line, this will calculate it
         /// </summary>
-        public string GetOutputSizeParam(EncodingJobInfo state,
+        public string GetOutputSizeParam(
+            EncodingJobInfo state,
             EncodingOptions options,
             string outputVideoCodec,
             bool allowTimeStampCopy = true)
@@ -1790,8 +1904,9 @@ namespace MediaBrowser.Controller.MediaEncoding
                 filters.Add("hwdownload");
 
                 // If transcoding from 10 bit, transform colour spaces too
-                if ( !string.IsNullOrEmpty(videoStream.PixelFormat) && videoStream.PixelFormat.IndexOf( "p10", StringComparison.OrdinalIgnoreCase ) != -1
-                    && string.Equals(outputVideoCodec, "libx264", StringComparison.OrdinalIgnoreCase ) )
+                if (!string.IsNullOrEmpty(videoStream.PixelFormat)
+                    && videoStream.PixelFormat.IndexOf("p10", StringComparison.OrdinalIgnoreCase) != -1
+                    && string.Equals(outputVideoCodec,"libx264", StringComparison.OrdinalIgnoreCase))
                 {
                     filters.Add("format=p010le");
                     filters.Add("format=nv12");
@@ -1800,7 +1915,6 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     filters.Add("format=nv12");
                 }
-
             }
 
             if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
@@ -1809,15 +1923,16 @@ namespace MediaBrowser.Controller.MediaEncoding
                 filters.Add("hwupload");
             }
 
-            if (state.DeInterlace("h264", true) && string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
+            if (state.DeInterlace("h264", true)
+                && string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
             {
-                filters.Add(string.Format("deinterlace_vaapi"));
+                filters.Add(string.Format(CultureInfo.InvariantCulture, "deinterlace_vaapi"));
             }
 
-            if ((state.DeInterlace("h264", true) || state.DeInterlace("h265", true) || state.DeInterlace("hevc", true)) &&
-                !string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
+            if ((state.DeInterlace("h264", true) || state.DeInterlace("h265", true) || state.DeInterlace("hevc", true))
+                && !string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
             {
-                var inputFramerate = videoStream == null ? null : videoStream.RealFrameRate;
+                var inputFramerate = videoStream?.RealFrameRate;
 
                 // If it is already 60fps then it will create an output framerate that is much too high for roku and others to handle
                 if (string.Equals(options.DeinterlaceMethod, "bobandweave", StringComparison.OrdinalIgnoreCase) && (inputFramerate ?? 60) <= 30)
@@ -1830,11 +1945,11 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
-            var inputWidth = videoStream == null ? null : videoStream.Width;
-            var inputHeight = videoStream == null ? null : videoStream.Height;
+            var inputWidth = videoStream?.Width;
+            var inputHeight = videoStream?.Height;
             var threeDFormat = state.MediaSource.Video3DFormat;
 
-            var videoDecoder = this.GetHardwareAcceleratedVideoDecoder(state, options);
+            var videoDecoder = GetHardwareAcceleratedVideoDecoder(state, options);
 
             filters.AddRange(GetScalingFilters(inputWidth, inputHeight, threeDFormat, videoDecoder, outputVideoCodec, request.Width, request.Height, request.MaxWidth, request.MaxHeight));
 
@@ -1852,6 +1967,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 {
                     filters.Add("hwmap");
                 }
+
                 if (allowTimeStampCopy)
                 {
                     output += " -copyts";
@@ -1860,7 +1976,10 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (filters.Count > 0)
             {
-                output += string.Format(" -vf \"{0}\"", string.Join(",", filters.ToArray()));
+                output += string.Format(
+                    CultureInfo.InvariantCulture,
+                    " -vf \"{0}\"",
+                    string.Join(",", filters));
             }
 
             return output;
@@ -1908,7 +2027,8 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
-            if (state.AudioStream != null && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs))
+            if (state.AudioStream != null
+                && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs))
             {
                 state.OutputAudioCodec = "copy";
             }
@@ -1925,14 +2045,10 @@ namespace MediaBrowser.Controller.MediaEncoding
         }
 
         public static string GetProbeSizeArgument(int numInputFiles)
-        {
-            return numInputFiles > 1 ? "-probesize 1G" : "";
-        }
+            => numInputFiles > 1 ? "-probesize 1G" : "";
 
         public static string GetAnalyzeDurationArgument(int numInputFiles)
-        {
-            return numInputFiles > 1 ? "-analyzeduration 200M" : "";
-        }
+            => numInputFiles > 1 ? "-analyzeduration 200M" : "";
 
         public string GetInputModifier(EncodingJobInfo state, EncodingOptions encodingOptions)
         {
@@ -2000,18 +2116,22 @@ namespace MediaBrowser.Controller.MediaEncoding
             {
                 flags.Add("+igndts");
             }
+
             if (state.IgnoreInputIndex)
             {
                 flags.Add("+ignidx");
             }
+
             if (state.GenPtsInput || string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
             {
                 flags.Add("+genpts");
             }
+
             if (state.DiscardCorruptFramesInput)
             {
                 flags.Add("+discardcorrupt");
             }
+
             if (state.EnableFastSeekInput)
             {
                 flags.Add("+fastseek");
@@ -2019,24 +2139,33 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (flags.Count > 0)
             {
-                inputModifier += " -fflags " + string.Join("", flags.ToArray());
+                inputModifier += " -fflags " + string.Join(string.Empty, flags);
             }
 
-            var videoDecoder = this.GetHardwareAcceleratedVideoDecoder(state, encodingOptions);
+            var videoDecoder = GetHardwareAcceleratedVideoDecoder(state, encodingOptions);
             if (!string.IsNullOrEmpty(videoDecoder))
             {
                 inputModifier += " " + videoDecoder;
 
-                var videoStream = state.VideoStream;
-                var inputWidth = videoStream == null ? null : videoStream.Width;
-                var inputHeight = videoStream == null ? null : videoStream.Height;
-                var request = state.BaseRequest;
-
-                var fixedOutputSize = GetFixedOutputSize(inputWidth, inputHeight, request.Width, request.Height, request.MaxWidth, request.MaxHeight);
-
-                if ((videoDecoder ?? string.Empty).IndexOf("_cuvid", StringComparison.OrdinalIgnoreCase) != -1 && fixedOutputSize.Item1.HasValue && fixedOutputSize.Item2.HasValue)
+                if ((videoDecoder ?? string.Empty).IndexOf("_cuvid", StringComparison.OrdinalIgnoreCase) != -1)
                 {
-                    inputModifier += string.Format(" -resize {0}x{1}", fixedOutputSize.Item1.Value.ToString(_usCulture), fixedOutputSize.Item2.Value.ToString(_usCulture));
+                    var videoStream = state.VideoStream;
+                    var inputWidth = videoStream?.Width;
+                    var inputHeight = videoStream?.Height;
+                    var request = state.BaseRequest;
+
+                    var (width, height) = GetFixedOutputSize(inputWidth, inputHeight, request.Width, request.Height, request.MaxWidth, request.MaxHeight);
+
+                    if ((videoDecoder ?? string.Empty).IndexOf("_cuvid", StringComparison.OrdinalIgnoreCase) != -1
+                        && width.HasValue
+                        && height.HasValue)
+                    {
+                        inputModifier += string.Format(
+                            CultureInfo.InvariantCulture,
+                            " -resize {0}x{1}",
+                            width.Value,
+                            height.Value);
+                    }
                 }
             }
 
@@ -2045,9 +2174,9 @@ namespace MediaBrowser.Controller.MediaEncoding
                 var outputVideoCodec = GetVideoEncoder(state, encodingOptions);
 
                 // Important: If this is ever re-enabled, make sure not to use it with wtv because it breaks seeking
-                if (!string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase) &&
-                    state.TranscodingType != TranscodingJobType.Progressive &&
-                    state.EnableBreakOnNonKeyFrames(outputVideoCodec))
+                if (!string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase)
+                    && state.TranscodingType != TranscodingJobType.Progressive
+                    && state.EnableBreakOnNonKeyFrames(outputVideoCodec))
                 {
                     inputModifier += " -noaccurate_seek";
                 }
@@ -2071,14 +2200,16 @@ namespace MediaBrowser.Controller.MediaEncoding
         }
 
 
-        public void AttachMediaSourceInfo(EncodingJobInfo state,
-          MediaSourceInfo mediaSource,
-          string requestedUrl)
+        public void AttachMediaSourceInfo(
+            EncodingJobInfo state,
+            MediaSourceInfo mediaSource,
+            string requestedUrl)
         {
             if (state == null)
             {
                 throw new ArgumentNullException(nameof(state));
             }
+
             if (mediaSource == null)
             {
                 throw new ArgumentNullException(nameof(mediaSource));
@@ -2136,15 +2267,16 @@ namespace MediaBrowser.Controller.MediaEncoding
             state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
             state.ReadInputAtNativeFramerate = mediaSource.ReadAtNativeFramerate;
 
-            if (state.ReadInputAtNativeFramerate ||
-                mediaSource.Protocol == MediaProtocol.File && string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase))
+            if (state.ReadInputAtNativeFramerate
+                || mediaSource.Protocol == MediaProtocol.File
+                && string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase))
             {
                 state.InputVideoSync = "-1";
                 state.InputAudioSync = "1";
             }
 
-            if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(mediaSource.Container, "asf", StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(mediaSource.Container, "asf", StringComparison.OrdinalIgnoreCase))
             {
                 // Seeing some stuttering when transcoding wma to audio-only HLS
                 state.InputAudioSync = "1";
@@ -2256,7 +2388,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 return null;
             }
 
-            return this.GetHardwareAcceleratedVideoDecoder(state.MediaSource.VideoType ?? VideoType.VideoFile, state.VideoStream, encodingOptions);
+            return GetHardwareAcceleratedVideoDecoder(state.MediaSource.VideoType ?? VideoType.VideoFile, state.VideoStream, encodingOptions);
         }
 
         public string GetHardwareAcceleratedVideoDecoder(VideoType videoType, MediaStream videoStream, EncodingOptions encodingOptions)
@@ -2269,9 +2401,9 @@ namespace MediaBrowser.Controller.MediaEncoding
                 return null;
             }
 
-            if (videoStream != null &&
-                !string.IsNullOrEmpty(videoStream.Codec) &&
-                !string.IsNullOrEmpty(encodingOptions.HardwareAccelerationType))
+            if (videoStream != null
+                && !string.IsNullOrEmpty(videoStream.Codec)
+                && !string.IsNullOrEmpty(encodingOptions.HardwareAccelerationType))
             {
                 if (string.Equals(encodingOptions.HardwareAccelerationType, "qsv", StringComparison.OrdinalIgnoreCase))
                 {
@@ -2469,11 +2601,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 codec = format;
             }
 
-            var args = " -codec:s:0 " + codec;
-
-            args += " -disposition:s:0 default";
-
-            return args;
+            return " -codec:s:0 " + codec + " -disposition:s:0 default";
         }
 
         public string GetProgressiveVideoFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, string outputPath, string defaultPreset)
@@ -2484,8 +2612,8 @@ namespace MediaBrowser.Controller.MediaEncoding
             var format = string.Empty;
             var keyFrame = string.Empty;
 
-            if (string.Equals(Path.GetExtension(outputPath), ".mp4", StringComparison.OrdinalIgnoreCase) &&
-                state.BaseRequest.Context == EncodingContext.Streaming)
+            if (string.Equals(Path.GetExtension(outputPath), ".mp4", StringComparison.OrdinalIgnoreCase)
+                && state.BaseRequest.Context == EncodingContext.Streaming)
             {
                 // Comparison: https://github.com/jansmolders86/mediacenterjs/blob/master/lib/transcoding/desktop.js
                 format = " -f mp4 -movflags frag_keyframe+empty_moov";
@@ -2495,7 +2623,9 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             var inputModifier = GetInputModifier(state, encodingOptions);
 
-            return string.Format("{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"",
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                "{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"",
                 inputModifier,
                 GetInputArgument(state, encodingOptions),
                 keyFrame,
@@ -2505,8 +2635,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                 GetProgressiveVideoAudioArguments(state, encodingOptions),
                 GetSubtitleEmbedArguments(state),
                 format,
-                outputPath
-                ).Trim();
+                outputPath).Trim();
         }
 
         public string GetOutputFFlags(EncodingJobInfo state)
@@ -2519,7 +2648,7 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (flags.Count > 0)
             {
-                return " -fflags " + string.Join("", flags.ToArray());
+                return " -fflags " + string.Join("", flags);
             }
 
             return string.Empty;
@@ -2536,9 +2665,9 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (string.Equals(videoCodec, "copy", StringComparison.OrdinalIgnoreCase))
             {
-                if (state.VideoStream != null &&
-                    string.Equals(state.OutputContainer, "ts", StringComparison.OrdinalIgnoreCase) &&
-                    !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
+                if (state.VideoStream != null
+                    && string.Equals(state.OutputContainer, "ts", StringComparison.OrdinalIgnoreCase)
+                    && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
                 {
                     string bitStreamArgs = GetBitStreamArgs(state.VideoStream);
                     if (!string.IsNullOrEmpty(bitStreamArgs))
@@ -2559,8 +2688,10 @@ namespace MediaBrowser.Controller.MediaEncoding
             }
             else
             {
-                var keyFrameArg = string.Format(" -force_key_frames \"expr:gte(t,n_forced*{0})\"",
-                    5.ToString(_usCulture));
+                var keyFrameArg = string.Format(
+                    CultureInfo.InvariantCulture,
+                    " -force_key_frames \"expr:gte(t,n_forced*{0})\"",
+                    5);
 
                 args += keyFrameArg;
 
@@ -2581,6 +2712,7 @@ namespace MediaBrowser.Controller.MediaEncoding
                     {
                         args += " -copyts";
                     }
+
                     args += " -avoid_negative_ts disabled -start_at_zero";
                 }
 
@@ -2681,39 +2813,22 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
-            var albumCoverInput = string.Empty;
-            var mapArgs = string.Empty;
-            var metadata = string.Empty;
-            var vn = string.Empty;
-
-            var hasArt = !string.IsNullOrEmpty(state.AlbumCoverPath);
-            hasArt = false;
-
-            if (hasArt)
-            {
-                albumCoverInput = " -i \"" + state.AlbumCoverPath + "\"";
-                mapArgs = " -map 0:a -map 1:v -c:1:v copy";
-                metadata = " -metadata:s:v title=\"Album cover\" -metadata:s:v comment=\"Cover(Front)\"";
-            }
-            else
-            {
-                vn = " -vn";
-            }
-
             var threads = GetNumberOfThreads(state, encodingOptions, null);
 
             var inputModifier = GetInputModifier(state, encodingOptions);
 
-            return string.Format("{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"",
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                "{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"",
                 inputModifier,
                 GetInputArgument(state, encodingOptions),
                 threads,
-                vn,
-                string.Join(" ", audioTranscodeParams.ToArray()),
+                " -vn",
+                string.Join(" ", audioTranscodeParams),
                 outputPath,
-                metadata,
-                albumCoverInput,
-                mapArgs).Trim();
+                string.Empty,
+                string.Empty,
+                string.Empty).Trim();
         }
 
     }
diff --git a/MediaBrowser.Controller/MediaEncoding/MediaEncoderHelpers.cs b/MediaBrowser.Controller/MediaEncoding/MediaEncoderHelpers.cs
index 7f842c1d0..5cedc3d57 100644
--- a/MediaBrowser.Controller/MediaEncoding/MediaEncoderHelpers.cs
+++ b/MediaBrowser.Controller/MediaEncoding/MediaEncoderHelpers.cs
@@ -1,8 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.MediaInfo;
 
 namespace MediaBrowser.Controller.MediaEncoding
 {
@@ -16,31 +16,26 @@ namespace MediaBrowser.Controller.MediaEncoding
         /// </summary>
         /// <param name="fileSystem">The file system.</param>
         /// <param name="videoPath">The video path.</param>
-        /// <param name="protocol">The protocol.</param>
         /// <param name="isoMount">The iso mount.</param>
         /// <param name="playableStreamFileNames">The playable stream file names.</param>
-        /// <returns>System.String[][].</returns>
-        public static string[] GetInputArgument(IFileSystem fileSystem, string videoPath, MediaProtocol protocol, IIsoMount isoMount, string[] playableStreamFileNames)
+        /// <returns>string[].</returns>
+        public static string[] GetInputArgument(IFileSystem fileSystem, string videoPath, IIsoMount isoMount, IReadOnlyCollection<string> playableStreamFileNames)
         {
-            if (playableStreamFileNames.Length > 0)
+            if (playableStreamFileNames.Count > 0)
             {
                 if (isoMount == null)
                 {
                     return GetPlayableStreamFiles(fileSystem, videoPath, playableStreamFileNames);
                 }
+
                 return GetPlayableStreamFiles(fileSystem, isoMount.MountedPath, playableStreamFileNames);
             }
 
             return new[] { videoPath };
         }
 
-        private static string[] GetPlayableStreamFiles(IFileSystem fileSystem, string rootPath, string[] filenames)
+        private static string[] GetPlayableStreamFiles(IFileSystem fileSystem, string rootPath, IEnumerable<string> filenames)
         {
-            if (filenames.Length == 0)
-            {
-                return new string[] { };
-            }
-
             var allFiles = fileSystem
                 .GetFilePaths(rootPath, true)
                 .ToArray();
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index a8874b6d0..75bb960c3 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -303,7 +303,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
         {
             var extractChapters = request.MediaType == DlnaProfileType.Video && request.ExtractChapters;
 
-            var inputFiles = MediaEncoderHelpers.GetInputArgument(FileSystem, request.MediaSource.Path, request.MediaSource.Protocol, request.MountedIso, request.PlayableStreamFileNames);
+            var inputFiles = MediaEncoderHelpers.GetInputArgument(FileSystem, request.MediaSource.Path, request.MountedIso, request.PlayableStreamFileNames);
 
             var probeSize = EncodingHelper.GetProbeSizeArgument(inputFiles.Length);
             string analyzeDuration;
diff --git a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
index d80084acf..e0b23108f 100644
--- a/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/VideoImageProvider.cs
@@ -62,7 +62,7 @@ namespace MediaBrowser.Providers.MediaInfo
         {
             var protocol = item.PathProtocol ?? MediaProtocol.File;
 
-            var inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, item.Path, protocol, null, item.GetPlayableStreamFileNames(_mediaEncoder));
+            var inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, item.Path, null, item.GetPlayableStreamFileNames(_mediaEncoder));
 
             var mediaStreams =
                 item.GetMediaStreams();
diff --git a/MediaBrowser.XbmcMetadata/EntryPoint.cs b/MediaBrowser.XbmcMetadata/EntryPoint.cs
index 992991a7e..fe4d50efa 100644
--- a/MediaBrowser.XbmcMetadata/EntryPoint.cs
+++ b/MediaBrowser.XbmcMetadata/EntryPoint.cs
@@ -16,27 +16,30 @@ namespace MediaBrowser.XbmcMetadata
     {
         private readonly IUserDataManager _userDataManager;
         private readonly ILogger _logger;
-        private readonly ILibraryManager _libraryManager;
         private readonly IProviderManager _providerManager;
         private readonly IConfigurationManager _config;
 
-        public EntryPoint(IUserDataManager userDataManager, ILibraryManager libraryManager, ILogger logger, IProviderManager providerManager, IConfigurationManager config)
+        public EntryPoint(
+            IUserDataManager userDataManager,
+            ILogger logger,
+            IProviderManager providerManager,
+            IConfigurationManager config)
         {
             _userDataManager = userDataManager;
-            _libraryManager = libraryManager;
             _logger = logger;
             _providerManager = providerManager;
             _config = config;
         }
 
+        /// <inheritdoc />
         public Task RunAsync()
         {
-            _userDataManager.UserDataSaved += _userDataManager_UserDataSaved;
+            _userDataManager.UserDataSaved += OnUserDataSaved;
 
             return Task.CompletedTask;
         }
 
-        void _userDataManager_UserDataSaved(object sender, UserDataSaveEventArgs e)
+        private void OnUserDataSaved(object sender, UserDataSaveEventArgs e)
         {
             if (e.SaveReason == UserDataSaveReason.PlaybackFinished || e.SaveReason == UserDataSaveReason.TogglePlayed || e.SaveReason == UserDataSaveReason.UpdateUserRating)
             {
@@ -47,9 +50,10 @@ namespace MediaBrowser.XbmcMetadata
             }
         }
 
+        /// <inheritdoc />
         public void Dispose()
         {
-            _userDataManager.UserDataSaved -= _userDataManager_UserDataSaved;
+            _userDataManager.UserDataSaved -= OnUserDataSaved;
         }
 
         private void SaveMetadataForItem(BaseItem item, ItemUpdateType updateReason)
diff --git a/MediaBrowser.XbmcMetadata/Savers/AlbumNfoSaver.cs b/MediaBrowser.XbmcMetadata/Savers/AlbumNfoSaver.cs
index 430b93199..a1905bf26 100644
--- a/MediaBrowser.XbmcMetadata/Savers/AlbumNfoSaver.cs
+++ b/MediaBrowser.XbmcMetadata/Savers/AlbumNfoSaver.cs
@@ -15,16 +15,30 @@ namespace MediaBrowser.XbmcMetadata.Savers
 {
     public class AlbumNfoSaver : BaseNfoSaver
     {
+        public AlbumNfoSaver(
+            IFileSystem fileSystem,
+            IServerConfigurationManager configurationManager,
+            ILibraryManager libraryManager,
+            IUserManager userManager,
+            IUserDataManager userDataManager,
+            ILogger logger)
+            : base(fileSystem, configurationManager, libraryManager, userManager, userDataManager, logger)
+        {
+        }
+
+        /// <inheritdoc />
         protected override string GetLocalSavePath(BaseItem item)
         {
             return Path.Combine(item.Path, "album.nfo");
         }
 
+        /// <inheritdoc />
         protected override string GetRootElementName(BaseItem item)
         {
             return "album";
         }
 
+        /// <inheritdoc />
         public override bool IsEnabledFor(BaseItem item, ItemUpdateType updateType)
         {
             if (!item.SupportsLocalMetadata)
@@ -35,6 +49,7 @@ namespace MediaBrowser.XbmcMetadata.Savers
             return item is MusicAlbum && updateType >= MinimumUpdateType;
         }
 
+        /// <inheritdoc />
         protected override void WriteCustomElements(BaseItem item, XmlWriter writer)
         {
             var album = (MusicAlbum)item;
@@ -52,8 +67,6 @@ namespace MediaBrowser.XbmcMetadata.Savers
             AddTracks(album.Tracks, writer);
         }
 
-        private readonly CultureInfo UsCulture = new CultureInfo("en-US");
-
         private void AddTracks(IEnumerable<BaseItem> tracks, XmlWriter writer)
         {
             foreach (var track in tracks.OrderBy(i => i.ParentIndexNumber ?? 0).ThenBy(i => i.IndexNumber ?? 0))
@@ -62,7 +75,7 @@ namespace MediaBrowser.XbmcMetadata.Savers
 
                 if (track.IndexNumber.HasValue)
                 {
-                    writer.WriteElementString("position", track.IndexNumber.Value.ToString(UsCulture));
+                    writer.WriteElementString("position", track.IndexNumber.Value.ToString(CultureInfo.InvariantCulture));
                 }
 
                 if (!string.IsNullOrEmpty(track.Name))
@@ -81,21 +94,19 @@ namespace MediaBrowser.XbmcMetadata.Savers
             }
         }
 
+        /// <inheritdoc />
         protected override List<string> GetTagsUsed(BaseItem item)
         {
             var list = base.GetTagsUsed(item);
-            list.AddRange(new string[]
-            {
-                "track",
-                "artist",
-                "albumartist"
-            });
-            return list;
-        }
+            list.AddRange(
+                new string[]
+                {
+                    "track",
+                    "artist",
+                    "albumartist"
+                });
 
-        public AlbumNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager, ILogger logger)
-            : base(fileSystem, configurationManager, libraryManager, userManager, userDataManager, logger)
-        {
+            return list;
         }
     }
 }
diff --git a/MediaBrowser.sln b/MediaBrowser.sln
index 3ed86d65c..39839e273 100644
--- a/MediaBrowser.sln
+++ b/MediaBrowser.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.26730.3
@@ -41,8 +41,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Emby.Naming", "Emby.Naming\
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Emby.XmlTv", "Emby.XmlTv\Emby.XmlTv\Emby.XmlTv.csproj", "{6EAFA7F0-8A82-49E6-B2FA-086C5CAEA95B}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IsoMounter", "Emby.IsoMounting\IsoMounter\IsoMounter.csproj", "{9BA471D2-6DB9-4DBF-B3A0-9FB3171F94A6}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MediaBrowser.MediaEncoding", "MediaBrowser.MediaEncoding\MediaBrowser.MediaEncoding.csproj", "{960295EE-4AF4-4440-A525-B4C295B01A61}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jellyfin.Server", "Jellyfin.Server\Jellyfin.Server.csproj", "{07E39F42-A2C6-4B32-AF8C-725F957A73FF}"
@@ -141,10 +139,6 @@ Global
 		{6EAFA7F0-8A82-49E6-B2FA-086C5CAEA95B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6EAFA7F0-8A82-49E6-B2FA-086C5CAEA95B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6EAFA7F0-8A82-49E6-B2FA-086C5CAEA95B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9BA471D2-6DB9-4DBF-B3A0-9FB3171F94A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9BA471D2-6DB9-4DBF-B3A0-9FB3171F94A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9BA471D2-6DB9-4DBF-B3A0-9FB3171F94A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9BA471D2-6DB9-4DBF-B3A0-9FB3171F94A6}.Release|Any CPU.Build.0 = Release|Any CPU
 		{960295EE-4AF4-4440-A525-B4C295B01A61}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{960295EE-4AF4-4440-A525-B4C295B01A61}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{960295EE-4AF4-4440-A525-B4C295B01A61}.Release|Any CPU.ActiveCfg = Release|Any CPU