Merge branch 'jellyfin:master' into master

1 files changed, 658 insertions, 431 deletions

diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index 5099ccb2a..9279cb220 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -1,15 +1,19 @@
+#nullable disable
+#pragma warning disable CS1591
+
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Xml;
+using Jellyfin.Extensions;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.Extensions;
-using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.MediaInfo;
 using Microsoft.Extensions.Logging;
 
@@ -17,42 +21,69 @@ namespace MediaBrowser.MediaEncoding.Probing
 {
     public class ProbeResultNormalizer
     {
-        private readonly CultureInfo _usCulture = new CultureInfo("en-US");
+        // When extracting subtitles, the maximum length to consider (to avoid invalid filenames)
+        private const int MaxSubtitleDescriptionExtractionLength = 100;
+
+        private const string ArtistReplaceValue = " | ";
+
+        private readonly char[] _nameDelimiters = { '/', '|', ';', '\\' };
+
+        private static readonly Regex _performerPattern = new (@"(?<name>.*) \((?<instrument>.*)\)");
+
         private readonly ILogger _logger;
-        private readonly IFileSystem _fileSystem;
+        private readonly ILocalizationManager _localization;
+
+        private string[] _splitWhiteList;
 
-        public ProbeResultNormalizer(ILogger logger, IFileSystem fileSystem)
+        public ProbeResultNormalizer(ILogger logger, ILocalizationManager localization)
         {
             _logger = logger;
-            _fileSystem = fileSystem;
+            _localization = localization;
         }
 
+        private IReadOnlyList<string> SplitWhitelist => _splitWhiteList ??= new string[]
+        {
+            "AC/DC",
+            "Au/Ra",
+            "이달의 소녀 1/3",
+            "LOONA 1/3",
+            "LOONA / yyxy",
+            "LOONA / ODD EYE CIRCLE",
+            "K/DA",
+            "22/7"
+        };
+
         public MediaInfo GetMediaInfo(InternalMediaInfoResult data, VideoType? videoType, bool isAudio, string path, MediaProtocol protocol)
         {
             var info = new MediaInfo
             {
                 Path = path,
-                Protocol = protocol
+                Protocol = protocol,
+                VideoType = videoType
             };
 
             FFProbeHelpers.NormalizeFFProbeResult(data);
             SetSize(data, info);
 
-            var internalStreams = data.streams ?? new MediaStreamInfo[] { };
+            var internalStreams = data.Streams ?? Array.Empty<MediaStreamInfo>();
 
-            info.MediaStreams = internalStreams.Select(s => GetMediaStream(isAudio, s, data.format))
+            info.MediaStreams = internalStreams.Select(s => GetMediaStream(isAudio, s, data.Format))
                 .Where(i => i != null)
                 // Drop subtitle streams if we don't know the codec because it will just cause failures if we don't know how to handle them
                 .Where(i => i.Type != MediaStreamType.Subtitle || !string.IsNullOrWhiteSpace(i.Codec))
                 .ToList();
 
-            if (data.format != null)
+            info.MediaAttachments = internalStreams.Select(GetMediaAttachment)
+                .Where(i => i != null)
+                .ToList();
+
+            if (data.Format != null)
             {
-                info.Container = NormalizeFormat(data.format.format_name);
+                info.Container = NormalizeFormat(data.Format.FormatName);
 
-                if (!string.IsNullOrEmpty(data.format.bit_rate))
+                if (!string.IsNullOrEmpty(data.Format.BitRate))
                 {
-                    if (int.TryParse(data.format.bit_rate, NumberStyles.Any, _usCulture, out var value))
+                    if (int.TryParse(data.Format.BitRate, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
                     {
                         info.Bitrate = value;
                     }
@@ -62,58 +93,66 @@ namespace MediaBrowser.MediaEncoding.Probing
             var tags = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
             var tagStreamType = isAudio ? "audio" : "video";
 
-            if (data.streams != null)
-            {
-                var tagStream = data.streams.FirstOrDefault(i => string.Equals(i.codec_type, tagStreamType, StringComparison.OrdinalIgnoreCase));
+            var tagStream = data.Streams?.FirstOrDefault(i => string.Equals(i.CodecType, tagStreamType, StringComparison.OrdinalIgnoreCase));
 
-                if (tagStream != null && tagStream.tags != null)
+            if (tagStream?.Tags != null)
+            {
+                foreach (var (key, value) in tagStream.Tags)
                 {
-                    foreach (var pair in tagStream.tags)
-                    {
-                        tags[pair.Key] = pair.Value;
-                    }
+                    tags[key] = value;
                 }
             }
 
-            if (data.format != null && data.format.tags != null)
+            if (data.Format?.Tags != null)
             {
-                foreach (var pair in data.format.tags)
+                foreach (var (key, value) in data.Format.Tags)
                 {
-                    tags[pair.Key] = pair.Value;
+                    tags[key] = value;
                 }
             }
 
             FetchGenres(info, tags);
-            var overview = FFProbeHelpers.GetDictionaryValue(tags, "synopsis");
 
-            if (string.IsNullOrWhiteSpace(overview))
-            {
-                overview = FFProbeHelpers.GetDictionaryValue(tags, "description");
-            }
-            if (string.IsNullOrWhiteSpace(overview))
+            info.Name = tags.GetFirstNotNullNorWhiteSpaceValue("title", "title-eng");
+            info.ForcedSortName = tags.GetFirstNotNullNorWhiteSpaceValue("sort_name", "title-sort", "titlesort");
+            info.Overview = tags.GetFirstNotNullNorWhiteSpaceValue("synopsis", "description", "desc");
+
+            info.IndexNumber = FFProbeHelpers.GetDictionaryNumericValue(tags, "episode_sort");
+            info.ParentIndexNumber = FFProbeHelpers.GetDictionaryNumericValue(tags, "season_number");
+            info.ShowName = tags.GetValueOrDefault("show_name");
+            info.ProductionYear = FFProbeHelpers.GetDictionaryNumericValue(tags, "date");
+
+            // Several different forms of retail/premiere date
+            info.PremiereDate =
+                FFProbeHelpers.GetDictionaryDateTime(tags, "originaldate") ??
+                FFProbeHelpers.GetDictionaryDateTime(tags, "retaildate") ??
+                FFProbeHelpers.GetDictionaryDateTime(tags, "retail date") ??
+                FFProbeHelpers.GetDictionaryDateTime(tags, "retail_date") ??
+                FFProbeHelpers.GetDictionaryDateTime(tags, "date_released") ??
+                FFProbeHelpers.GetDictionaryDateTime(tags, "date");
+
+            // Set common metadata for music (audio) and music videos (video)
+            info.Album = tags.GetValueOrDefault("album");
+
+            if (tags.TryGetValue("artists", out var artists) && !string.IsNullOrWhiteSpace(artists))
             {
-                overview = FFProbeHelpers.GetDictionaryValue(tags, "desc");
+                info.Artists = SplitDistinctArtists(artists, new[] { '/', ';' }, false).ToArray();
             }
-
-            if (!string.IsNullOrWhiteSpace(overview))
+            else
             {
-                info.Overview = overview;
+                var artist = tags.GetFirstNotNullNorWhiteSpaceValue("artist");
+                info.Artists = artist == null
+                    ? Array.Empty<string>()
+                    : SplitDistinctArtists(artist, _nameDelimiters, true).ToArray();
             }
 
-            var title = FFProbeHelpers.GetDictionaryValue(tags, "title");
-            if (!string.IsNullOrWhiteSpace(title))
+            // Guess ProductionYear from PremiereDate if missing
+            if (!info.ProductionYear.HasValue && info.PremiereDate.HasValue)
             {
-                info.Name = title;
+                info.ProductionYear = info.PremiereDate.Value.Year;
             }
 
-            info.ProductionYear = FFProbeHelpers.GetDictionaryNumericValue(tags, "date");
-
-            // Several different forms of retaildate
-            info.PremiereDate = FFProbeHelpers.GetDictionaryDateTime(tags, "retaildate") ??
-                FFProbeHelpers.GetDictionaryDateTime(tags, "retail date") ??
-                FFProbeHelpers.GetDictionaryDateTime(tags, "retail_date") ??
-                FFProbeHelpers.GetDictionaryDateTime(tags, "date");
-
+            // Set mediaType-specific metadata
             if (isAudio)
             {
                 SetAudioRuntimeTicks(data, info);
@@ -127,10 +166,10 @@ namespace MediaBrowser.MediaEncoding.Probing
             {
                 FetchStudios(info, tags, "copyright");
 
-                var iTunEXTC = FFProbeHelpers.GetDictionaryValue(tags, "iTunEXTC");
-                if (!string.IsNullOrWhiteSpace(iTunEXTC))
+                var iTunExtc = tags.GetFirstNotNullNorWhiteSpaceValue("iTunEXTC");
+                if (iTunExtc != null)
                 {
-                    var parts = iTunEXTC.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
+                    var parts = iTunExtc.Split('|', StringSplitOptions.RemoveEmptyEntries);
                     // Example
                     // mpaa|G|100|For crude humor
                     if (parts.Length > 1)
@@ -144,15 +183,15 @@ namespace MediaBrowser.MediaEncoding.Probing
                     }
                 }
 
-                var itunesXml = FFProbeHelpers.GetDictionaryValue(tags, "iTunMOVI");
-                if (!string.IsNullOrWhiteSpace(itunesXml))
+                var iTunXml = tags.GetFirstNotNullNorWhiteSpaceValue("iTunMOVI");
+                if (iTunXml != null)
                 {
-                    FetchFromItunesInfo(itunesXml, info);
+                    FetchFromItunesInfo(iTunXml, info);
                 }
 
-                if (data.format != null && !string.IsNullOrEmpty(data.format.duration))
+                if (data.Format != null && !string.IsNullOrEmpty(data.Format.Duration))
                 {
-                    info.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(data.format.duration, _usCulture)).Ticks;
+                    info.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(data.Format.Duration, CultureInfo.InvariantCulture)).Ticks;
                 }
 
                 FetchWtvInfo(info, data);
@@ -164,8 +203,7 @@ namespace MediaBrowser.MediaEncoding.Probing
 
                 ExtractTimestamp(info);
 
-                var stereoMode = GetDictionaryValue(tags, "stereo_mode");
-                if (string.Equals(stereoMode, "left_right", StringComparison.OrdinalIgnoreCase))
+                if (tags.TryGetValue("stereo_mode", out var stereoMode) && string.Equals(stereoMode, "left_right", StringComparison.OrdinalIgnoreCase))
                 {
                     info.Video3DFormat = Video3DFormat.FullSideBySide;
                 }
@@ -215,17 +253,39 @@ namespace MediaBrowser.MediaEncoding.Probing
 
             var channelsValue = channels.Value;
 
-            if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
+            {
+                switch (channelsValue)
+                {
+                    case <= 2:
+                        return 192000;
+                    case >= 5:
+                        return 320000;
+                }
+            }
+
+            if (string.Equals(codec, "ac3", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))
             {
-                if (channelsValue <= 2)
+                switch (channelsValue)
                 {
-                    return 192000;
+                    case <= 2:
+                        return 192000;
+                    case >= 5:
+                        return 640000;
                 }
+            }
 
-                if (channelsValue >= 5)
+            if (string.Equals(codec, "flac", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(codec, "alac", StringComparison.OrdinalIgnoreCase))
+            {
+                switch (channelsValue)
                 {
-                    return 320000;
+                    case <= 2:
+                        return 960000;
+                    case >= 5:
+                        return 2880000;
                 }
             }
 
@@ -246,52 +306,51 @@ namespace MediaBrowser.MediaEncoding.Probing
 
             // <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n<plist version=\"1.0\">\n<dict>\n\t<key>cast</key>\n\t<array>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Blender Foundation</string>\n\t\t</dict>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Janus Bager Kristensen</string>\n\t\t</dict>\n\t</array>\n\t<key>directors</key>\n\t<array>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Sacha Goedegebure</string>\n\t\t</dict>\n\t</array>\n\t<key>studio</key>\n\t<string>Blender Foundation</string>\n</dict>\n</plist>\n
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
+            using (var streamReader = new StreamReader(stream))
             {
-                using (var streamReader = new StreamReader(stream))
+                try
                 {
-                    try
+                    using (var reader = XmlReader.Create(streamReader))
                     {
-                        // Use XmlReader for best performance
-                        using (var reader = XmlReader.Create(streamReader))
-                        {
-                            reader.MoveToContent();
-                            reader.Read();
+                        reader.MoveToContent();
+                        reader.Read();
 
-                            // Loop through each element
-                            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
+                        // Loop through each element
+                        while (!reader.EOF && reader.ReadState == ReadState.Interactive)
+                        {
+                            if (reader.NodeType == XmlNodeType.Element)
                             {
-                                if (reader.NodeType == XmlNodeType.Element)
-                                {
-                                    switch (reader.Name)
-                                    {
-                                        case "dict":
-                                            if (reader.IsEmptyElement)
-                                            {
-                                                reader.Read();
-                                                continue;
-                                            }
-                                            using (var subtree = reader.ReadSubtree())
-                                            {
-                                                ReadFromDictNode(subtree, info);
-                                            }
-                                            break;
-                                        default:
-                                            reader.Skip();
-                                            break;
-                                    }
-                                }
-                                else
+                                switch (reader.Name)
                                 {
-                                    reader.Read();
+                                    case "dict":
+                                        if (reader.IsEmptyElement)
+                                        {
+                                            reader.Read();
+                                            continue;
+                                        }
+
+                                        using (var subtree = reader.ReadSubtree())
+                                        {
+                                            ReadFromDictNode(subtree, info);
+                                        }
+
+                                        break;
+                                    default:
+                                        reader.Skip();
+                                        break;
                                 }
                             }
+                            else
+                            {
+                                reader.Read();
+                            }
                         }
                     }
-                    catch (XmlException)
-                    {
-                        // I've seen probe examples where the iTunMOVI value is just "<"
-                        // So we should not allow this to fail the entire probing operation
-                    }
+                }
+                catch (XmlException)
+                {
+                    // I've seen probe examples where the iTunMOVI value is just "<"
+                    // So we should not allow this to fail the entire probing operation
                 }
             }
         }
@@ -316,6 +375,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                             {
                                 ProcessPairs(currentKey, pairs, info);
                             }
+
                             currentKey = reader.ReadElementContentAsString();
                             pairs = new List<NameValuePair>();
                             break;
@@ -329,6 +389,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                                     Value = value
                                 });
                             }
+
                             break;
                         case "array":
                             if (reader.IsEmptyElement)
@@ -336,6 +397,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                                 reader.Read();
                                 continue;
                             }
+
                             using (var subtree = reader.ReadSubtree())
                             {
                                 if (!string.IsNullOrWhiteSpace(currentKey))
@@ -343,6 +405,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                                     pairs.AddRange(ReadValueArray(subtree));
                                 }
                             }
+
                             break;
                         default:
                             reader.Skip();
@@ -358,7 +421,6 @@ namespace MediaBrowser.MediaEncoding.Probing
 
         private List<NameValuePair> ReadValueArray(XmlReader reader)
         {
-
             var pairs = new List<NameValuePair>();
 
             reader.MoveToContent();
@@ -378,6 +440,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                                 reader.Read();
                                 continue;
                             }
+
                             using (var subtree = reader.ReadSubtree())
                             {
                                 var dict = GetNameValuePair(subtree);
@@ -386,6 +449,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                                     pairs.Add(dict);
                                 }
                             }
+
                             break;
                         default:
                             reader.Skip();
@@ -410,7 +474,6 @@ namespace MediaBrowser.MediaEncoding.Probing
                     .Where(i => !string.IsNullOrWhiteSpace(i))
                     .Distinct(StringComparer.OrdinalIgnoreCase)
                     .ToArray();
-
             }
             else if (string.Equals(key, "screenwriters", StringComparison.OrdinalIgnoreCase))
             {
@@ -422,7 +485,6 @@ namespace MediaBrowser.MediaEncoding.Probing
                         Type = PersonType.Writer
                     });
                 }
-
             }
             else if (string.Equals(key, "producers", StringComparison.OrdinalIgnoreCase))
             {
@@ -514,7 +576,41 @@ namespace MediaBrowser.MediaEncoding.Probing
         }
 
         /// <summary>
-        /// Converts ffprobe stream info to our MediaStream class
+        /// Converts ffprobe stream info to our MediaAttachment class.
+        /// </summary>
+        /// <param name="streamInfo">The stream info.</param>
+        /// <returns>MediaAttachments.</returns>
+        private MediaAttachment GetMediaAttachment(MediaStreamInfo streamInfo)
+        {
+            if (!string.Equals(streamInfo.CodecType, "attachment", StringComparison.OrdinalIgnoreCase)
+                && streamInfo.Disposition?.GetValueOrDefault("attached_pic") != 1)
+            {
+                return null;
+            }
+
+            var attachment = new MediaAttachment
+            {
+                Codec = streamInfo.CodecName,
+                Index = streamInfo.Index
+            };
+
+            if (!string.IsNullOrWhiteSpace(streamInfo.CodecTagString))
+            {
+                attachment.CodecTag = streamInfo.CodecTagString;
+            }
+
+            if (streamInfo.Tags != null)
+            {
+                attachment.FileName = GetDictionaryValue(streamInfo.Tags, "filename");
+                attachment.MimeType = GetDictionaryValue(streamInfo.Tags, "mimetype");
+                attachment.Comment = GetDictionaryValue(streamInfo.Tags, "comment");
+            }
+
+            return attachment;
+        }
+
+        /// <summary>
+        /// Converts ffprobe stream info to our MediaStream class.
         /// </summary>
         /// <param name="isAudio">if set to <c>true</c> [is info].</param>
         /// <param name="streamInfo">The stream info.</param>
@@ -523,91 +619,114 @@ namespace MediaBrowser.MediaEncoding.Probing
         private MediaStream GetMediaStream(bool isAudio, MediaStreamInfo streamInfo, MediaFormatInfo formatInfo)
         {
             // These are mp4 chapters
-            if (string.Equals(streamInfo.codec_name, "mov_text", StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(streamInfo.CodecName, "mov_text", StringComparison.OrdinalIgnoreCase))
             {
                 // Edit: but these are also sometimes subtitles?
-                //return null;
+                // return null;
             }
 
             var stream = new MediaStream
             {
-                Codec = streamInfo.codec_name,
-                Profile = streamInfo.profile,
-                Level = streamInfo.level,
-                Index = streamInfo.index,
-                PixelFormat = streamInfo.pix_fmt,
-                NalLengthSize = streamInfo.nal_length_size,
-                TimeBase = streamInfo.time_base,
-                CodecTimeBase = streamInfo.codec_time_base
+                Codec = streamInfo.CodecName,
+                Profile = streamInfo.Profile,
+                Level = streamInfo.Level,
+                Index = streamInfo.Index,
+                PixelFormat = streamInfo.PixelFormat,
+                NalLengthSize = streamInfo.NalLengthSize,
+                TimeBase = streamInfo.TimeBase,
+                CodecTimeBase = streamInfo.CodecTimeBase
             };
 
-            if (string.Equals(streamInfo.is_avc, "true", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(streamInfo.is_avc, "1", StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(streamInfo.IsAvc, "true", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(streamInfo.IsAvc, "1", StringComparison.OrdinalIgnoreCase))
             {
                 stream.IsAVC = true;
             }
-            else if (string.Equals(streamInfo.is_avc, "false", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(streamInfo.is_avc, "0", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(streamInfo.IsAvc, "false", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(streamInfo.IsAvc, "0", StringComparison.OrdinalIgnoreCase))
             {
                 stream.IsAVC = false;
             }
 
-            if (!string.IsNullOrWhiteSpace(streamInfo.field_order) && !string.Equals(streamInfo.field_order, "progressive", StringComparison.OrdinalIgnoreCase))
+            if (!string.IsNullOrWhiteSpace(streamInfo.FieldOrder) && !string.Equals(streamInfo.FieldOrder, "progressive", StringComparison.OrdinalIgnoreCase))
             {
                 stream.IsInterlaced = true;
             }
 
             // Filter out junk
-            if (!string.IsNullOrWhiteSpace(streamInfo.codec_tag_string) && streamInfo.codec_tag_string.IndexOf("[0]", StringComparison.OrdinalIgnoreCase) == -1)
+            if (!string.IsNullOrWhiteSpace(streamInfo.CodecTagString) && !streamInfo.CodecTagString.Contains("[0]", StringComparison.OrdinalIgnoreCase))
             {
-                stream.CodecTag = streamInfo.codec_tag_string;
+                stream.CodecTag = streamInfo.CodecTagString;
             }
 
-            if (streamInfo.tags != null)
+            if (streamInfo.Tags != null)
             {
-                stream.Language = GetDictionaryValue(streamInfo.tags, "language");
-                stream.Comment = GetDictionaryValue(streamInfo.tags, "comment");
-                stream.Title = GetDictionaryValue(streamInfo.tags, "title");
+                stream.Language = GetDictionaryValue(streamInfo.Tags, "language");
+                stream.Comment = GetDictionaryValue(streamInfo.Tags, "comment");
+                stream.Title = GetDictionaryValue(streamInfo.Tags, "title");
             }
 
-            if (string.Equals(streamInfo.codec_type, "audio", StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(streamInfo.CodecType, "audio", StringComparison.OrdinalIgnoreCase))
             {
                 stream.Type = MediaStreamType.Audio;
 
-                stream.Channels = streamInfo.channels;
+                stream.Channels = streamInfo.Channels;
 
-                if (!string.IsNullOrEmpty(streamInfo.sample_rate))
+                if (!string.IsNullOrEmpty(streamInfo.SampleRate))
                 {
-                    if (int.TryParse(streamInfo.sample_rate, NumberStyles.Any, _usCulture, out var value))
+                    if (int.TryParse(streamInfo.SampleRate, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
                     {
                         stream.SampleRate = value;
                     }
                 }
 
-                stream.ChannelLayout = ParseChannelLayout(streamInfo.channel_layout);
+                stream.ChannelLayout = ParseChannelLayout(streamInfo.ChannelLayout);
 
-                if (streamInfo.bits_per_sample > 0)
+                if (streamInfo.BitsPerSample > 0)
+                {
+                    stream.BitDepth = streamInfo.BitsPerSample;
+                }
+                else if (streamInfo.BitsPerRawSample > 0)
                 {
-                    stream.BitDepth = streamInfo.bits_per_sample;
+                    stream.BitDepth = streamInfo.BitsPerRawSample;
                 }
-                else if (streamInfo.bits_per_raw_sample > 0)
+
+                if (string.IsNullOrEmpty(stream.Title))
                 {
-                    stream.BitDepth = streamInfo.bits_per_raw_sample;
+                    // mp4 missing track title workaround: fall back to handler_name if populated
+                    string handlerName = GetDictionaryValue(streamInfo.Tags, "handler_name");
+                    if (!string.IsNullOrEmpty(handlerName))
+                    {
+                        stream.Title = handlerName;
+                    }
                 }
             }
-            else if (string.Equals(streamInfo.codec_type, "subtitle", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(streamInfo.CodecType, "subtitle", StringComparison.OrdinalIgnoreCase))
             {
                 stream.Type = MediaStreamType.Subtitle;
                 stream.Codec = NormalizeSubtitleCodec(stream.Codec);
+                stream.LocalizedUndefined = _localization.GetLocalizedString("Undefined");
+                stream.LocalizedDefault = _localization.GetLocalizedString("Default");
+                stream.LocalizedForced = _localization.GetLocalizedString("Forced");
+
+                if (string.IsNullOrEmpty(stream.Title))
+                {
+                    // mp4 missing track title workaround: fall back to handler_name if populated and not the default "SubtitleHandler"
+                    string handlerName = GetDictionaryValue(streamInfo.Tags, "handler_name");
+                    if (!string.IsNullOrEmpty(handlerName) && !string.Equals(handlerName, "SubtitleHandler", StringComparison.OrdinalIgnoreCase))
+                    {
+                        stream.Title = handlerName;
+                    }
+                }
             }
-            else if (string.Equals(streamInfo.codec_type, "video", StringComparison.OrdinalIgnoreCase))
+            else if (string.Equals(streamInfo.CodecType, "video", StringComparison.OrdinalIgnoreCase))
             {
                 stream.Type = isAudio || string.Equals(stream.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase) || string.Equals(stream.Codec, "gif", StringComparison.OrdinalIgnoreCase) || string.Equals(stream.Codec, "png", StringComparison.OrdinalIgnoreCase)
                     ? MediaStreamType.EmbeddedImage
                     : MediaStreamType.Video;
 
-                stream.AverageFrameRate = GetFrameRate(streamInfo.avg_frame_rate);
-                stream.RealFrameRate = GetFrameRate(streamInfo.r_frame_rate);
+                stream.AverageFrameRate = GetFrameRate(streamInfo.AverageFrameRate);
+                stream.RealFrameRate = GetFrameRate(streamInfo.RFrameRate);
 
                 if (isAudio || string.Equals(stream.Codec, "gif", StringComparison.OrdinalIgnoreCase) ||
                     string.Equals(stream.Codec, "png", StringComparison.OrdinalIgnoreCase))
@@ -632,29 +751,66 @@ namespace MediaBrowser.MediaEncoding.Probing
                     stream.Type = MediaStreamType.Video;
                 }
 
-                stream.Width = streamInfo.width;
-                stream.Height = streamInfo.height;
+                stream.Width = streamInfo.Width;
+                stream.Height = streamInfo.Height;
                 stream.AspectRatio = GetAspectRatio(streamInfo);
 
-                if (streamInfo.bits_per_sample > 0)
+                if (streamInfo.BitsPerSample > 0)
                 {
-                    stream.BitDepth = streamInfo.bits_per_sample;
+                    stream.BitDepth = streamInfo.BitsPerSample;
                 }
-                else if (streamInfo.bits_per_raw_sample > 0)
+                else if (streamInfo.BitsPerRawSample > 0)
                 {
-                    stream.BitDepth = streamInfo.bits_per_raw_sample;
+                    stream.BitDepth = streamInfo.BitsPerRawSample;
                 }
 
-                //stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase) ||
+                if (!stream.BitDepth.HasValue)
+                {
+                    if (!string.IsNullOrEmpty(streamInfo.PixelFormat)
+                        && streamInfo.PixelFormat.Contains("p10", StringComparison.OrdinalIgnoreCase))
+                    {
+                        stream.BitDepth = 10;
+                    }
+
+                    if (!string.IsNullOrEmpty(streamInfo.Profile)
+                        && (streamInfo.Profile.Contains("Main 10", StringComparison.OrdinalIgnoreCase)
+                            || streamInfo.Profile.Contains("High 10", StringComparison.OrdinalIgnoreCase)
+                            || streamInfo.Profile.Contains("Profile 2", StringComparison.OrdinalIgnoreCase)))
+                    {
+                        stream.BitDepth = 10;
+                    }
+                }
+
+                // stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase) ||
                 //    string.Equals(stream.AspectRatio, "2.35:1", StringComparison.OrdinalIgnoreCase) ||
                 //    string.Equals(stream.AspectRatio, "2.40:1", StringComparison.OrdinalIgnoreCase);
 
                 // http://stackoverflow.com/questions/17353387/how-to-detect-anamorphic-video-with-ffprobe
-                stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase);
+                stream.IsAnamorphic = string.Equals(streamInfo.SampleAspectRatio, "0:1", StringComparison.OrdinalIgnoreCase);
+
+                if (streamInfo.Refs > 0)
+                {
+                    stream.RefFrames = streamInfo.Refs;
+                }
 
-                if (streamInfo.refs > 0)
+                if (!string.IsNullOrEmpty(streamInfo.ColorRange))
                 {
-                    stream.RefFrames = streamInfo.refs;
+                    stream.ColorRange = streamInfo.ColorRange;
+                }
+
+                if (!string.IsNullOrEmpty(streamInfo.ColorSpace))
+                {
+                    stream.ColorSpace = streamInfo.ColorSpace;
+                }
+
+                if (!string.IsNullOrEmpty(streamInfo.ColorTransfer))
+                {
+                    stream.ColorTransfer = streamInfo.ColorTransfer;
+                }
+
+                if (!string.IsNullOrEmpty(streamInfo.ColorPrimaries))
+                {
+                    stream.ColorPrimaries = streamInfo.ColorPrimaries;
                 }
             }
             else
@@ -665,18 +821,22 @@ namespace MediaBrowser.MediaEncoding.Probing
             // Get stream bitrate
             var bitrate = 0;
 
-            if (!string.IsNullOrEmpty(streamInfo.bit_rate))
+            if (!string.IsNullOrEmpty(streamInfo.BitRate))
             {
-                if (int.TryParse(streamInfo.bit_rate, NumberStyles.Any, _usCulture, out var value))
+                if (int.TryParse(streamInfo.BitRate, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
                 {
                     bitrate = value;
                 }
             }
 
-            if (bitrate == 0 && formatInfo != null && !string.IsNullOrEmpty(formatInfo.bit_rate) && stream.Type == MediaStreamType.Video)
+            // The bitrate info of FLAC musics and some videos is included in formatInfo.
+            if (bitrate == 0
+                && formatInfo != null
+                && !string.IsNullOrEmpty(formatInfo.BitRate)
+                && (stream.Type == MediaStreamType.Video || (isAudio && stream.Type == MediaStreamType.Audio)))
             {
                 // If the stream info doesn't have a bitrate get the value from the media format info
-                if (int.TryParse(formatInfo.bit_rate, NumberStyles.Any, _usCulture, out var value))
+                if (int.TryParse(formatInfo.BitRate, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
                 {
                     bitrate = value;
                 }
@@ -687,14 +847,47 @@ namespace MediaBrowser.MediaEncoding.Probing
                 stream.BitRate = bitrate;
             }
 
-            if (streamInfo.disposition != null)
+            // Extract bitrate info from tag "BPS" if possible.
+            if (!stream.BitRate.HasValue
+                && (string.Equals(streamInfo.CodecType, "audio", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(streamInfo.CodecType, "video", StringComparison.OrdinalIgnoreCase)))
+            {
+                var bps = GetBPSFromTags(streamInfo);
+                if (bps > 0)
+                {
+                    stream.BitRate = bps;
+                }
+            }
+
+            // Get average bitrate info from tag "NUMBER_OF_BYTES" and "DURATION" if possible.
+            if (!stream.BitRate.HasValue
+                && (string.Equals(streamInfo.CodecType, "audio", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(streamInfo.CodecType, "video", StringComparison.OrdinalIgnoreCase)))
             {
-                var isDefault = GetDictionaryValue(streamInfo.disposition, "default");
-                var isForced = GetDictionaryValue(streamInfo.disposition, "forced");
+                var durationInSeconds = GetRuntimeSecondsFromTags(streamInfo);
+                var bytes = GetNumberOfBytesFromTags(streamInfo);
+                if (durationInSeconds != null && bytes != null)
+                {
+                    var bps = Convert.ToInt32(bytes * 8 / durationInSeconds, CultureInfo.InvariantCulture);
+                    if (bps > 0)
+                    {
+                        stream.BitRate = bps;
+                    }
+                }
+            }
 
-                stream.IsDefault = string.Equals(isDefault, "1", StringComparison.OrdinalIgnoreCase);
+            var disposition = streamInfo.Disposition;
+            if (disposition != null)
+            {
+                if (disposition.GetValueOrDefault("default") == 1)
+                {
+                    stream.IsDefault = true;
+                }
 
-                stream.IsForced = string.Equals(isForced, "1", StringComparison.OrdinalIgnoreCase);
+                if (disposition.GetValueOrDefault("forced") == 1)
+                {
+                    stream.IsForced = true;
+                }
             }
 
             NormalizeStreamTitle(stream);
@@ -716,12 +909,12 @@ namespace MediaBrowser.MediaEncoding.Probing
         }
 
         /// <summary>
-        /// Gets a string from an FFProbeResult tags dictionary
+        /// Gets a string from an FFProbeResult tags dictionary.
         /// </summary>
         /// <param name="tags">The tags.</param>
         /// <param name="key">The key.</param>
         /// <returns>System.String.</returns>
-        private string GetDictionaryValue(Dictionary<string, string> tags, string key)
+        private string GetDictionaryValue(IReadOnlyDictionary<string, string> tags, string key)
         {
             if (tags == null)
             {
@@ -729,6 +922,7 @@ namespace MediaBrowser.MediaEncoding.Probing
             }
 
             tags.TryGetValue(key, out var val);
+
             return val;
         }
 
@@ -736,7 +930,7 @@ namespace MediaBrowser.MediaEncoding.Probing
         {
             if (string.IsNullOrEmpty(input))
             {
-                return input;
+                return null;
             }
 
             return input.Split('(').FirstOrDefault();
@@ -744,17 +938,17 @@ namespace MediaBrowser.MediaEncoding.Probing
 
         private string GetAspectRatio(MediaStreamInfo info)
         {
-            var original = info.display_aspect_ratio;
+            var original = info.DisplayAspectRatio;
 
             var parts = (original ?? string.Empty).Split(':');
             if (!(parts.Length == 2 &&
-                int.TryParse(parts[0], NumberStyles.Any, _usCulture, out var width) &&
-                int.TryParse(parts[1], NumberStyles.Any, _usCulture, out var height) &&
+                int.TryParse(parts[0], NumberStyles.Any, CultureInfo.InvariantCulture, out var width) &&
+                int.TryParse(parts[1], NumberStyles.Any, CultureInfo.InvariantCulture, out var height) &&
                 width > 0 &&
                 height > 0))
             {
-                width = info.width;
-                height = info.height;
+                width = info.Width;
+                height = info.Height;
             }
 
             if (width > 0 && height > 0)
@@ -824,176 +1018,219 @@ namespace MediaBrowser.MediaEncoding.Probing
         /// <returns>System.Nullable{System.Single}.</returns>
         private float? GetFrameRate(string value)
         {
-            if (!string.IsNullOrEmpty(value))
+            if (string.IsNullOrEmpty(value))
             {
-                var parts = value.Split('/');
+                return null;
+            }
 
-                float result;
+            var parts = value.Split('/');
 
-                if (parts.Length == 2)
-                {
-                    result = float.Parse(parts[0], _usCulture) / float.Parse(parts[1], _usCulture);
-                }
-                else
-                {
-                    result = float.Parse(parts[0], _usCulture);
-                }
+            float result;
 
-                return float.IsNaN(result) ? (float?)null : result;
+            if (parts.Length == 2)
+            {
+                result = float.Parse(parts[0], CultureInfo.InvariantCulture) / float.Parse(parts[1], CultureInfo.InvariantCulture);
+            }
+            else
+            {
+                result = float.Parse(parts[0], CultureInfo.InvariantCulture);
             }
 
-            return null;
+            return float.IsNaN(result) ? null : result;
         }
 
         private void SetAudioRuntimeTicks(InternalMediaInfoResult result, MediaInfo data)
         {
-            if (result.streams != null)
+            // Get the first info stream
+            var stream = result.Streams?.FirstOrDefault(s => string.Equals(s.CodecType, "audio", StringComparison.OrdinalIgnoreCase));
+            if (stream == null)
             {
-                // Get the first info stream
-                var stream = result.streams.FirstOrDefault(s => string.Equals(s.codec_type, "audio", StringComparison.OrdinalIgnoreCase));
+                return;
+            }
 
-                if (stream != null)
-                {
-                    // Get duration from stream properties
-                    var duration = stream.duration;
+            // Get duration from stream properties
+            var duration = stream.Duration;
 
-                    // If it's not there go into format properties
-                    if (string.IsNullOrEmpty(duration))
-                    {
-                        duration = result.format.duration;
-                    }
+            // If it's not there go into format properties
+            if (string.IsNullOrEmpty(duration))
+            {
+                duration = result.Format.Duration;
+            }
 
-                    // If we got something, parse it
-                    if (!string.IsNullOrEmpty(duration))
-                    {
-                        data.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(duration, _usCulture)).Ticks;
-                    }
-                }
+            // If we got something, parse it
+            if (!string.IsNullOrEmpty(duration))
+            {
+                data.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(duration, CultureInfo.InvariantCulture)).Ticks;
             }
         }
 
-        private void SetSize(InternalMediaInfoResult data, MediaInfo info)
+        private int? GetBPSFromTags(MediaStreamInfo streamInfo)
         {
-            if (data.format != null)
+            if (streamInfo?.Tags == null)
             {
-                if (!string.IsNullOrEmpty(data.format.size))
-                {
-                    info.Size = long.Parse(data.format.size, _usCulture);
-                }
-                else
-                {
-                    info.Size = null;
-                }
+                return null;
+            }
+
+            var bps = GetDictionaryValue(streamInfo.Tags, "BPS-eng") ?? GetDictionaryValue(streamInfo.Tags, "BPS");
+            if (!string.IsNullOrEmpty(bps)
+                && int.TryParse(bps, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedBps))
+            {
+                return parsedBps;
             }
+
+            return null;
         }
 
-        private void SetAudioInfoFromTags(MediaInfo audio, Dictionary<string, string> tags)
+        private double? GetRuntimeSecondsFromTags(MediaStreamInfo streamInfo)
         {
-            var composer = FFProbeHelpers.GetDictionaryValue(tags, "composer");
-            if (!string.IsNullOrWhiteSpace(composer))
+            if (streamInfo?.Tags == null)
             {
-                var peoples = new List<BaseItemPerson>();
-                foreach (var person in Split(composer, false))
-                {
-                    peoples.Add(new BaseItemPerson { Name = person, Type = PersonType.Composer });
-                }
-                audio.People = peoples.ToArray();
+                return null;
             }
 
-            //var conductor = FFProbeHelpers.GetDictionaryValue(tags, "conductor");
-            //if (!string.IsNullOrWhiteSpace(conductor))
-            //{
-            //    foreach (var person in Split(conductor, false))
-            //    {
-            //        audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Conductor });
-            //    }
-            //}
+            var duration = GetDictionaryValue(streamInfo.Tags, "DURATION-eng") ?? GetDictionaryValue(streamInfo.Tags, "DURATION");
+            if (!string.IsNullOrEmpty(duration) && TimeSpan.TryParse(duration, out var parsedDuration))
+            {
+                return parsedDuration.TotalSeconds;
+            }
 
-            //var lyricist = FFProbeHelpers.GetDictionaryValue(tags, "lyricist");
-            //if (!string.IsNullOrWhiteSpace(lyricist))
-            //{
-            //    foreach (var person in Split(lyricist, false))
-            //    {
-            //        audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Lyricist });
-            //    }
-            //}
+            return null;
+        }
 
-            // Check for writer some music is tagged that way as alternative to composer/lyricist
-            var writer = FFProbeHelpers.GetDictionaryValue(tags, "writer");
+        private long? GetNumberOfBytesFromTags(MediaStreamInfo streamInfo)
+        {
+            if (streamInfo?.Tags == null)
+            {
+                return null;
+            }
 
-            if (!string.IsNullOrWhiteSpace(writer))
+            var numberOfBytes = GetDictionaryValue(streamInfo.Tags, "NUMBER_OF_BYTES-eng")
+                                ?? GetDictionaryValue(streamInfo.Tags, "NUMBER_OF_BYTES");
+            if (!string.IsNullOrEmpty(numberOfBytes)
+                && long.TryParse(numberOfBytes, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedBytes))
             {
-                var peoples = new List<BaseItemPerson>();
-                foreach (var person in Split(writer, false))
-                {
-                    peoples.Add(new BaseItemPerson { Name = person, Type = PersonType.Writer });
-                }
-                audio.People = peoples.ToArray();
+                return parsedBytes;
             }
 
-            audio.Album = FFProbeHelpers.GetDictionaryValue(tags, "album");
+            return null;
+        }
 
-            var artists = FFProbeHelpers.GetDictionaryValue(tags, "artists");
+        private void SetSize(InternalMediaInfoResult data, MediaInfo info)
+        {
+            if (data.Format == null)
+            {
+                return;
+            }
 
-            if (!string.IsNullOrWhiteSpace(artists))
+            info.Size = string.IsNullOrEmpty(data.Format.Size) ? null : long.Parse(data.Format.Size, CultureInfo.InvariantCulture);
+        }
+
+        private void SetAudioInfoFromTags(MediaInfo audio, IReadOnlyDictionary<string, string> tags)
+        {
+            var people = new List<BaseItemPerson>();
+            if (tags.TryGetValue("composer", out var composer) && !string.IsNullOrWhiteSpace(composer))
             {
-                audio.Artists = SplitArtists(artists, new[] { '/', ';' }, false)
-                    .DistinctNames()
-                    .ToArray();
+                foreach (var person in Split(composer, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Composer });
+                }
             }
-            else
+
+            if (tags.TryGetValue("conductor", out var conductor) && !string.IsNullOrWhiteSpace(conductor))
             {
-                var artist = FFProbeHelpers.GetDictionaryValue(tags, "artist");
-                if (string.IsNullOrWhiteSpace(artist))
+                foreach (var person in Split(conductor, false))
                 {
-                    audio.Artists = new string[] { };
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Conductor });
                 }
-                else
+            }
+
+            if (tags.TryGetValue("lyricist", out var lyricist) && !string.IsNullOrWhiteSpace(lyricist))
+            {
+                foreach (var person in Split(lyricist, false))
                 {
-                    audio.Artists = SplitArtists(artist, _nameDelimiters, true)
-                    .DistinctNames()
-                        .ToArray();
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Lyricist });
                 }
             }
 
-            var albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "albumartist");
-            if (string.IsNullOrWhiteSpace(albumArtist))
+            if (tags.TryGetValue("performer", out var performer) && !string.IsNullOrWhiteSpace(performer))
             {
-                albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "album artist");
+                foreach (var person in Split(performer, false))
+                {
+                    Match match = _performerPattern.Match(person);
+
+                    // If the performer doesn't have any instrument/role associated, it won't match. In that case, chances are it's simply a band name, so we skip it.
+                    if (match.Success)
+                    {
+                        people.Add(new BaseItemPerson
+                        {
+                            Name = match.Groups["name"].Value,
+                            Type = PersonType.Actor,
+                            Role = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(match.Groups["instrument"].Value)
+                        });
+                    }
+                }
             }
-            if (string.IsNullOrWhiteSpace(albumArtist))
+
+            // In cases where there isn't sufficient information as to which role a writer performed on a recording, tagging software uses the "writer" tag.
+            if (tags.TryGetValue("writer", out var writer) && !string.IsNullOrWhiteSpace(writer))
             {
-                albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "album_artist");
+                foreach (var person in Split(writer, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Writer });
+                }
             }
 
-            if (string.IsNullOrWhiteSpace(albumArtist))
+            if (tags.TryGetValue("arranger", out var arranger) && !string.IsNullOrWhiteSpace(arranger))
             {
-                audio.AlbumArtists = new string[] { };
+                foreach (var person in Split(arranger, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Arranger });
+                }
             }
-            else
+
+            if (tags.TryGetValue("engineer", out var engineer) && !string.IsNullOrWhiteSpace(engineer))
             {
-                audio.AlbumArtists = SplitArtists(albumArtist, _nameDelimiters, true)
-                    .DistinctNames()
-                    .ToArray();
+                foreach (var person in Split(engineer, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Engineer });
+                }
+            }
+
+            if (tags.TryGetValue("mixer", out var mixer) && !string.IsNullOrWhiteSpace(mixer))
+            {
+                foreach (var person in Split(mixer, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Mixer });
+                }
+            }
 
+            if (tags.TryGetValue("remixer", out var remixer) && !string.IsNullOrWhiteSpace(remixer))
+            {
+                foreach (var person in Split(remixer, false))
+                {
+                    people.Add(new BaseItemPerson { Name = person, Type = PersonType.Remixer });
+                }
             }
 
+            audio.People = people.ToArray();
+
+            // Set album artist
+            var albumArtist = tags.GetFirstNotNullNorWhiteSpaceValue("albumartist", "album artist", "album_artist");
+            audio.AlbumArtists = albumArtist != null
+                ? SplitDistinctArtists(albumArtist, _nameDelimiters, true).ToArray()
+                : Array.Empty<string>();
+
+            // Set album artist to artist if empty
             if (audio.AlbumArtists.Length == 0)
             {
                 audio.AlbumArtists = audio.Artists;
             }
 
             // Track number
-            audio.IndexNumber = GetDictionaryDiscValue(tags, "track");
+            audio.IndexNumber = GetDictionaryTrackOrDiscNumber(tags, "track");
 
             // Disc number
-            audio.ParentIndexNumber = GetDictionaryDiscValue(tags, "disc");
-
-            // If we don't have a ProductionYear try and get it from PremiereDate
-            if (audio.PremiereDate.HasValue && !audio.ProductionYear.HasValue)
-            {
-                audio.ProductionYear = audio.PremiereDate.Value.ToLocalTime().Year;
-            }
+            audio.ParentIndexNumber = GetDictionaryTrackOrDiscNumber(tags, "disc");
 
             // There's several values in tags may or may not be present
             FetchStudios(audio, tags, "organization");
@@ -1001,26 +1238,26 @@ namespace MediaBrowser.MediaEncoding.Probing
             FetchStudios(audio, tags, "publisher");
             FetchStudios(audio, tags, "label");
 
-            // These support mulitple values, but for now we only store the first.
-            var mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Artist Id"));
-            if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ALBUMARTISTID"));
-            audio.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, mb);
+            // These support multiple values, but for now we only store the first.
+            var mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Album Artist Id"))
+                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ALBUMARTISTID"));
+            audio.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, mb);
 
-            mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Artist Id"));
-            if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ARTISTID"));
-            audio.SetProviderId(MetadataProviders.MusicBrainzArtist, mb);
+            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Artist Id"))
+                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ARTISTID"));
+            audio.SetProviderId(MetadataProvider.MusicBrainzArtist, mb);
 
-            mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Id"));
-            if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ALBUMID"));
-            audio.SetProviderId(MetadataProviders.MusicBrainzAlbum, mb);
+            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Album Id"))
+                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ALBUMID"));
+            audio.SetProviderId(MetadataProvider.MusicBrainzAlbum, mb);
 
-            mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Release Group Id"));
-            if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_RELEASEGROUPID"));
-            audio.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, mb);
+            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Release Group Id"))
+                 ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_RELEASEGROUPID"));
+            audio.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, mb);
 
-            mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Release Track Id"));
-            if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_RELEASETRACKID"));
-            audio.SetProviderId(MetadataProviders.MusicBrainzTrack, mb);
+            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Release Track Id"))
+                 ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_RELEASETRACKID"));
+            audio.SetProviderId(MetadataProvider.MusicBrainzTrack, mb);
         }
 
         private string GetMultipleMusicBrainzId(string value)
@@ -1030,13 +1267,11 @@ namespace MediaBrowser.MediaEncoding.Probing
                 return null;
             }
 
-            return value.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
+            return value.Split('/', StringSplitOptions.RemoveEmptyEntries)
                 .Select(i => i.Trim())
                 .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
         }
 
-        private readonly char[] _nameDelimiters = { '/', '|', ';', '\\' };
-
         /// <summary>
         /// Splits the specified val.
         /// </summary>
@@ -1045,20 +1280,18 @@ namespace MediaBrowser.MediaEncoding.Probing
         /// <returns>System.String[][].</returns>
         private IEnumerable<string> Split(string val, bool allowCommaDelimiter)
         {
-            // Only use the comma as a delimeter if there are no slashes or pipes.
+            // Only use the comma as a delimiter if there are no slashes or pipes.
             // We want to be careful not to split names that have commas in them
-            var delimeter = !allowCommaDelimiter || _nameDelimiters.Any(i => val.IndexOf(i) != -1) ?
+            var delimiter = !allowCommaDelimiter || _nameDelimiters.Any(i => val.IndexOf(i, StringComparison.Ordinal) != -1) ?
                 _nameDelimiters :
                 new[] { ',' };
 
-            return val.Split(delimeter, StringSplitOptions.RemoveEmptyEntries)
+            return val.Split(delimiter, StringSplitOptions.RemoveEmptyEntries)
                 .Where(i => !string.IsNullOrWhiteSpace(i))
                 .Select(i => i.Trim());
         }
 
-        private const string ArtistReplaceValue = " | ";
-
-        private IEnumerable<string> SplitArtists(string val, char[] delimiters, bool splitFeaturing)
+        private IEnumerable<string> SplitDistinctArtists(string val, char[] delimiters, bool splitFeaturing)
         {
             if (splitFeaturing)
             {
@@ -1068,7 +1301,7 @@ namespace MediaBrowser.MediaEncoding.Probing
 
             var artistsFound = new List<string>();
 
-            foreach (var whitelistArtist in GetSplitWhitelist())
+            foreach (var whitelistArtist in SplitWhitelist)
             {
                 var originalVal = val;
                 val = val.Replace(whitelistArtist, "|", StringComparison.OrdinalIgnoreCase);
@@ -1084,123 +1317,107 @@ namespace MediaBrowser.MediaEncoding.Probing
                 .Select(i => i.Trim());
 
             artistsFound.AddRange(artists);
-            return artistsFound;
-        }
-
-
-        private List<string> _splitWhiteList = null;
-
-        private IEnumerable<string> GetSplitWhitelist()
-        {
-            if (_splitWhiteList == null)
-            {
-                _splitWhiteList = new List<string>
-                        {
-                            "AC/DC"
-                        };
-            }
-
-            return _splitWhiteList;
+            return artistsFound.DistinctNames();
         }
 
         /// <summary>
-        /// Gets the studios from the tags collection
+        /// Gets the studios from the tags collection.
         /// </summary>
         /// <param name="info">The info.</param>
         /// <param name="tags">The tags.</param>
         /// <param name="tagName">Name of the tag.</param>
-        private void FetchStudios(MediaInfo info, Dictionary<string, string> tags, string tagName)
+        private void FetchStudios(MediaInfo info, IReadOnlyDictionary<string, string> tags, string tagName)
         {
-            var val = FFProbeHelpers.GetDictionaryValue(tags, tagName);
+            var val = tags.GetValueOrDefault(tagName);
 
-            if (!string.IsNullOrEmpty(val))
+            if (string.IsNullOrEmpty(val))
             {
-                var studios = Split(val, true);
-                var studioList = new List<string>();
+                return;
+            }
+
+            var studios = Split(val, true);
+            var studioList = new List<string>();
 
-                foreach (var studio in studios)
+            foreach (var studio in studios)
+            {
+                if (string.IsNullOrWhiteSpace(studio))
                 {
-                    // Sometimes the artist name is listed here, account for that
-                    if (info.Artists.Contains(studio, StringComparer.OrdinalIgnoreCase))
-                    {
-                        continue;
-                    }
-                    if (info.AlbumArtists.Contains(studio, StringComparer.OrdinalIgnoreCase))
-                    {
-                        continue;
-                    }
+                    continue;
+                }
 
-                    studioList.Add(studio);
+                // Don't add artist/album artist name to studios, even if it's listed there
+                if (info.Artists.Contains(studio, StringComparer.OrdinalIgnoreCase)
+                    || info.AlbumArtists.Contains(studio, StringComparer.OrdinalIgnoreCase))
+                {
+                    continue;
                 }
 
-                info.Studios = studioList
-                    .Where(i => !string.IsNullOrWhiteSpace(i))
-                    .Distinct(StringComparer.OrdinalIgnoreCase)
-                    .ToArray();
+                studioList.Add(studio);
             }
+
+            info.Studios = studioList
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
         }
 
         /// <summary>
-        /// Gets the genres from the tags collection
+        /// Gets the genres from the tags collection.
         /// </summary>
         /// <param name="info">The information.</param>
         /// <param name="tags">The tags.</param>
-        private void FetchGenres(MediaInfo info, Dictionary<string, string> tags)
+        private void FetchGenres(MediaInfo info, IReadOnlyDictionary<string, string> tags)
         {
-            var val = FFProbeHelpers.GetDictionaryValue(tags, "genre");
+            var genreVal = tags.GetValueOrDefault("genre");
+            if (string.IsNullOrEmpty(genreVal))
+            {
+                return;
+            }
 
-            if (!string.IsNullOrEmpty(val))
+            var genres = new List<string>(info.Genres);
+            foreach (var genre in Split(genreVal, true))
             {
-                var genres = new List<string>(info.Genres);
-                foreach (var genre in Split(val, true))
+                if (string.IsNullOrWhiteSpace(genre))
                 {
-                    genres.Add(genre);
+                    continue;
                 }
 
-                info.Genres = genres
-                    .Where(i => !string.IsNullOrWhiteSpace(i))
-                    .Distinct(StringComparer.OrdinalIgnoreCase)
-                    .ToArray();
+                genres.Add(genre);
             }
+
+            info.Genres = genres
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
         }
 
         /// <summary>
-        /// Gets the disc number, which is sometimes can be in the form of '1', or '1/3'
+        /// Gets the track or disc number, which can be in the form of '1', or '1/3'.
         /// </summary>
         /// <param name="tags">The tags.</param>
         /// <param name="tagName">Name of the tag.</param>
-        /// <returns>System.Nullable{System.Int32}.</returns>
-        private int? GetDictionaryDiscValue(Dictionary<string, string> tags, string tagName)
+        /// <returns>The track or disc number, or null, if missing or not parseable.</returns>
+        private static int? GetDictionaryTrackOrDiscNumber(IReadOnlyDictionary<string, string> tags, string tagName)
         {
-            var disc = FFProbeHelpers.GetDictionaryValue(tags, tagName);
+            var disc = tags.GetValueOrDefault(tagName);
 
-            if (!string.IsNullOrEmpty(disc))
+            if (!string.IsNullOrEmpty(disc) && int.TryParse(disc.AsSpan().LeftPart('/'), out var discNum))
             {
-                disc = disc.Split('/')[0];
-
-                if (int.TryParse(disc, out var num))
-                {
-                    return num;
-                }
+                return discNum;
             }
 
             return null;
         }
 
-        private ChapterInfo GetChapterInfo(MediaChapter chapter)
+        private static ChapterInfo GetChapterInfo(MediaChapter chapter)
         {
             var info = new ChapterInfo();
 
-            if (chapter.tags != null)
+            if (chapter.Tags != null && chapter.Tags.TryGetValue("title", out string name))
             {
-                if (chapter.tags.TryGetValue("title", out string name))
-                {
-                    info.Name = name;
-                }
+                info.Name = name;
             }
 
             // Limit accuracy to milliseconds to match xml saving
-            var secondsString = chapter.start_time;
+            var secondsString = chapter.StartTime;
 
             if (double.TryParse(secondsString, NumberStyles.Any, CultureInfo.InvariantCulture, out var seconds))
             {
@@ -1211,18 +1428,16 @@ namespace MediaBrowser.MediaEncoding.Probing
             return info;
         }
 
-        private const int MaxSubtitleDescriptionExtractionLength = 100; // When extracting subtitles, the maximum length to consider (to avoid invalid filenames)
-
         private void FetchWtvInfo(MediaInfo video, InternalMediaInfoResult data)
         {
-            if (data.format == null || data.format.tags == null)
+            var tags = data.Format?.Tags;
+
+            if (tags == null)
             {
                 return;
             }
 
-            var genres = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/Genre");
-
-            if (!string.IsNullOrWhiteSpace(genres))
+            if (tags.TryGetValue("WM/Genre", out var genres) && !string.IsNullOrWhiteSpace(genres))
             {
                 var genreList = genres.Split(new[] { ';', '/', ',' }, StringSplitOptions.RemoveEmptyEntries)
                     .Where(i => !string.IsNullOrWhiteSpace(i))
@@ -1236,16 +1451,12 @@ namespace MediaBrowser.MediaEncoding.Probing
                 }
             }
 
-            var officialRating = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/ParentalRating");
-
-            if (!string.IsNullOrWhiteSpace(officialRating))
+            if (tags.TryGetValue("WM/ParentalRating", out var officialRating) && !string.IsNullOrWhiteSpace(officialRating))
             {
                 video.OfficialRating = officialRating;
             }
 
-            var people = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/MediaCredits");
-
-            if (!string.IsNullOrEmpty(people))
+            if (tags.TryGetValue("WM/MediaCredits", out var people) && !string.IsNullOrEmpty(people))
             {
                 video.People = people.Split(new[] { ';', '/' }, StringSplitOptions.RemoveEmptyEntries)
                     .Where(i => !string.IsNullOrWhiteSpace(i))
@@ -1253,29 +1464,21 @@ namespace MediaBrowser.MediaEncoding.Probing
                     .ToArray();
             }
 
-            var year = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/OriginalReleaseTime");
-            if (!string.IsNullOrWhiteSpace(year))
+            if (tags.TryGetValue("WM/OriginalReleaseTime", out var year) && int.TryParse(year, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedYear))
             {
-                if (int.TryParse(year, NumberStyles.Integer, _usCulture, out var val))
-                {
-                    video.ProductionYear = val;
-                }
+                video.ProductionYear = parsedYear;
             }
 
-            var premiereDateString = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/MediaOriginalBroadcastDateTime");
-            if (!string.IsNullOrWhiteSpace(premiereDateString))
+            // Credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
+            // DateTime is reported along with timezone info (typically Z i.e. UTC hence assume None)
+            if (tags.TryGetValue("WM/MediaOriginalBroadcastDateTime", out var premiereDateString) && DateTime.TryParse(year, null, DateTimeStyles.AdjustToUniversal, out var parsedDate))
             {
-                // Credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
-                // DateTime is reported along with timezone info (typically Z i.e. UTC hence assume None)
-                if (DateTime.TryParse(year, null, DateTimeStyles.None, out var val))
-                {
-                    video.PremiereDate = val.ToUniversalTime();
-                }
+                video.PremiereDate = parsedDate;
             }
 
-            var description = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/SubTitleDescription");
+            var description = tags.GetValueOrDefault("WM/SubTitleDescription");
 
-            var subTitle = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/SubTitle");
+            var subTitle = tags.GetValueOrDefault("WM/SubTitle");
 
             // For below code, credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
 
@@ -1284,31 +1487,51 @@ namespace MediaBrowser.MediaEncoding.Probing
             // OR -> COMMENT. SUBTITLE: DESCRIPTION
             // e.g. -> 4/13. The Doctor's Wife: Science fiction drama. When he follows a Time Lord distress signal, the Doctor puts Amy, Rory and his beloved TARDIS in grave danger. Also in HD. [AD,S]
             // e.g. -> CBeebies Bedtime Hour. The Mystery: Animated adventures of two friends who live on an island in the middle of the big city. Some of Abney and Teal's favourite objects are missing. [S]
-            if (string.IsNullOrWhiteSpace(subTitle) && !string.IsNullOrWhiteSpace(description) && description.Substring(0, Math.Min(description.Length, MaxSubtitleDescriptionExtractionLength)).Contains(":")) // Check within the Subtitle size limit, otherwise from description it can get too long creating an invalid filename
+            if (string.IsNullOrWhiteSpace(subTitle)
+                && !string.IsNullOrWhiteSpace(description)
+                && description.AsSpan()[..Math.Min(description.Length, MaxSubtitleDescriptionExtractionLength)].Contains(':')) // Check within the Subtitle size limit, otherwise from description it can get too long creating an invalid filename
             {
-                string[] parts = description.Split(':');
-                if (parts.Length > 0)
+                string[] descriptionParts = description.Split(':');
+                if (descriptionParts.Length > 0)
                 {
-                    string subtitle = parts[0];
+                    string subtitle = descriptionParts[0];
                     try
                     {
-                        if (subtitle.Contains("/")) // It contains a episode number and season number
+                        // Check if it contains a episode number and season number
+                        if (subtitle.Contains('/', StringComparison.Ordinal))
                         {
-                            string[] numbers = subtitle.Split(' ');
-                            video.IndexNumber = int.Parse(numbers[0].Replace(".", "").Split('/')[0]);
-                            int totalEpisodesInSeason = int.Parse(numbers[0].Replace(".", "").Split('/')[1]);
+                            string[] subtitleParts = subtitle.Split(' ');
+                            string[] numbers = subtitleParts[0].Replace(".", string.Empty, StringComparison.Ordinal).Split('/');
+                            video.IndexNumber = int.Parse(numbers[0], CultureInfo.InvariantCulture);
+                            // int totalEpisodesInSeason = int.Parse(numbers[1], CultureInfo.InvariantCulture);
 
-                            description = string.Join(" ", numbers, 1, numbers.Length - 1).Trim(); // Skip the first, concatenate the rest, clean up spaces and save it
+                            // Skip the numbers, concatenate the rest, trim and set as new description
+                            description = string.Join(' ', subtitleParts, 1, subtitleParts.Length - 1).Trim();
+                        }
+                        else if (subtitle.Contains('.', StringComparison.Ordinal))
+                        {
+                            var subtitleParts = subtitle.Split('.');
+                            description = string.Join('.', subtitleParts, 1, subtitleParts.Length - 1).Trim();
                         }
                         else
-                            throw new Exception(); // Switch to default parsing
+                        {
+                            description = subtitle.Trim();
+                        }
                     }
-                    catch // Default parsing
+                    catch (Exception ex)
                     {
-                        if (subtitle.Contains(".")) // skip the comment, keep the subtitle
-                            description = string.Join(".", subtitle.Split('.'), 1, subtitle.Split('.').Length - 1).Trim(); // skip the first
+                        _logger.LogError(ex, "Error while parsing subtitle field");
+
+                        // Fallback to default parsing
+                        if (subtitle.Contains('.', StringComparison.Ordinal))
+                        {
+                            var subtitleParts = subtitle.Split('.');
+                            description = string.Join('.', subtitleParts, 1, subtitleParts.Length - 1).Trim();
+                        }
                         else
-                            description = subtitle.Trim(); // Clean up whitespaces and save it
+                        {
+                            description = subtitle.Trim();
+                        }
                     }
                 }
             }
@@ -1321,34 +1544,38 @@ namespace MediaBrowser.MediaEncoding.Probing
 
         private void ExtractTimestamp(MediaInfo video)
         {
-            if (video.VideoType == VideoType.VideoFile)
+            if (video.VideoType != VideoType.VideoFile)
             {
-                if (string.Equals(video.Container, "mpeg2ts", StringComparison.OrdinalIgnoreCase) ||
-                    string.Equals(video.Container, "m2ts", StringComparison.OrdinalIgnoreCase) ||
-                    string.Equals(video.Container, "ts", StringComparison.OrdinalIgnoreCase))
-                {
-                    try
-                    {
-                        video.Timestamp = GetMpegTimestamp(video.Path);
+                return;
+            }
 
-                        _logger.LogDebug("Video has {timestamp} timestamp", video.Timestamp);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error extracting timestamp info from {path}", video.Path);
-                        video.Timestamp = null;
-                    }
-                }
+            if (!string.Equals(video.Container, "mpeg2ts", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(video.Container, "m2ts", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(video.Container, "ts", StringComparison.OrdinalIgnoreCase))
+            {
+                return;
+            }
+
+            try
+            {
+                video.Timestamp = GetMpegTimestamp(video.Path);
+                _logger.LogDebug("Video has {Timestamp} timestamp", video.Timestamp);
+            }
+            catch (Exception ex)
+            {
+                video.Timestamp = null;
+                _logger.LogError(ex, "Error extracting timestamp info from {Path}", video.Path);
             }
         }
 
+        // REVIEW: find out why the byte array needs to be 197 bytes long and comment the reason
         private TransportStreamTimestamp GetMpegTimestamp(string path)
         {
-            var packetBuffer = new byte['Å'];
+            var packetBuffer = new byte[197];
 
-            using (var fs = _fileSystem.GetFileStream(path, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.Read))
+            using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1))
             {
-                fs.Read(packetBuffer, 0, packetBuffer.Length);
+                fs.Read(packetBuffer);
             }
 
             if (packetBuffer[0] == 71)
@@ -1356,17 +1583,17 @@ namespace MediaBrowser.MediaEncoding.Probing
                 return TransportStreamTimestamp.None;
             }
 
-            if ((packetBuffer[4] == 71) && (packetBuffer['Ä'] == 71))
+            if ((packetBuffer[4] != 71) || (packetBuffer[196] != 71))
             {
-                if ((packetBuffer[0] == 0) && (packetBuffer[1] == 0) && (packetBuffer[2] == 0) && (packetBuffer[3] == 0))
-                {
-                    return TransportStreamTimestamp.Zero;
-                }
+                return TransportStreamTimestamp.None;
+            }
 
-                return TransportStreamTimestamp.Valid;
+            if ((packetBuffer[0] == 0) && (packetBuffer[1] == 0) && (packetBuffer[2] == 0) && (packetBuffer[3] == 0))
+            {
+                return TransportStreamTimestamp.Zero;
             }
 
-            return TransportStreamTimestamp.None;
+            return TransportStreamTimestamp.Valid;
         }
     }
 }