< Summary - Jellyfin

Information
Class: MediaBrowser.MediaEncoding.Probing.ProbeResultNormalizer
Assembly: MediaBrowser.MediaEncoding
File(s): /srv/git/jellyfin/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
Line coverage
79%
Covered lines: 575
Uncovered lines: 145
Coverable lines: 720
Total lines: 1678
Line coverage: 79.8%
Branch coverage
74%
Covered branches: 441
Total branches: 590
Branch coverage: 74.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_SplitWhitelist()100%22100%
GetMediaInfo(...)83.33%747292.85%
NormalizeFormat(...)85.71%141486.66%
GetEstimatedAudioBitrate(...)50%622662.5%
FetchFromItunesInfo(...)83.33%141276.92%
ReadFromDictNode(...)90%212087.09%
ReadValueArray(...)83.33%141277.77%
ProcessPairs(...)64.28%441446.66%
GetNameValuePair(...)92.85%141490.9%
NormalizeSubtitleCodec(...)62.5%10866.66%
GetMediaAttachment(...)90%1010100%
GetMediaStream(...)79.68%16712886.61%
NormalizeStreamTitle(...)100%44100%
GetDictionaryValue(...)100%22100%
ParseChannelLayout(...)100%22100%
GetAspectRatio(...)85.29%393483.87%
IsClose(...)100%11100%
GetFrameRate(...)60%141066.66%
SetAudioRuntimeTicks(...)62.5%9877.77%
GetBPSFromTags(...)62.5%10866.66%
GetRuntimeSecondsFromTags(...)62.5%10866.66%
GetNumberOfBytesFromTags(...)62.5%9871.42%
SetSize(...)75%44100%
SetAudioInfoFromTags(...)80%847085.93%
GetMultipleMusicBrainzId(...)100%22100%
Split(...)100%44100%
SplitDistinctArtists(...)83.33%6691.66%
FetchStudios(...)100%1010100%
FetchGenres(...)100%66100%
GetDictionaryTrackOrDiscNumber(...)50%2275%
GetChapterInfo(...)0%4260%
FetchWtvInfo(...)50%5654233.33%
ExtractTimestamp(...)87.5%9878.57%
GetMpegTimestamp(...)0%1211418.18%

File(s)

/srv/git/jellyfin/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs

#LineLine coverage
 1#nullable disable
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Globalization;
 6using System.IO;
 7using System.Linq;
 8using System.Text;
 9using System.Text.RegularExpressions;
 10using System.Xml;
 11using Jellyfin.Data.Enums;
 12using Jellyfin.Extensions;
 13using MediaBrowser.Controller.Extensions;
 14using MediaBrowser.Controller.Library;
 15using MediaBrowser.Model.Dto;
 16using MediaBrowser.Model.Entities;
 17using MediaBrowser.Model.Globalization;
 18using MediaBrowser.Model.MediaInfo;
 19using Microsoft.Extensions.Logging;
 20
 21namespace MediaBrowser.MediaEncoding.Probing
 22{
 23    /// <summary>
 24    /// Class responsible for normalizing FFprobe output.
 25    /// </summary>
 26    public partial class ProbeResultNormalizer
 27    {
 28        // When extracting subtitles, the maximum length to consider (to avoid invalid filenames)
 29        private const int MaxSubtitleDescriptionExtractionLength = 100;
 30
 31        private const string ArtistReplaceValue = " | ";
 32
 2033        private readonly char[] _nameDelimiters = { '/', '|', ';', '\\' };
 2034        private readonly string[] _webmVideoCodecs = { "av1", "vp8", "vp9" };
 2035        private readonly string[] _webmAudioCodecs = { "opus", "vorbis" };
 36
 37        private readonly ILogger _logger;
 38        private readonly ILocalizationManager _localization;
 39
 40        private string[] _splitWhiteList;
 41
 42        /// <summary>
 43        /// Initializes a new instance of the <see cref="ProbeResultNormalizer"/> class.
 44        /// </summary>
 45        /// <param name="logger">The <see cref="ILogger{ProbeResultNormalizer}"/> for use with the <see cref="ProbeResul
 46        /// <param name="localization">The <see cref="ILocalizationManager"/> for use with the <see cref="ProbeResultNor
 47        public ProbeResultNormalizer(ILogger logger, ILocalizationManager localization)
 48        {
 2049            _logger = logger;
 2050            _localization = localization;
 2051        }
 52
 553        private IReadOnlyList<string> SplitWhitelist => _splitWhiteList ??= new string[]
 554        {
 555            "AC/DC",
 556            "A/T/O/S",
 557            "As/Hi Soundworks",
 558            "Au/Ra",
 559            "Bremer/McCoy",
 560            "b/bqスタヂオ",
 561            "DOV/S",
 562            "DJ'TEKINA//SOMETHING",
 563            "IX/ON",
 564            "J-CORE SLi//CER",
 565            "M(a/u)SH",
 566            "Kaoru/Brilliance",
 567            "signum/ii",
 568            "Richiter(LORB/DUGEM DI BARAT)",
 569            "이달의 소녀 1/3",
 570            "R!N / Gemie",
 571            "LOONA 1/3",
 572            "LOONA / yyxy",
 573            "LOONA / ODD EYE CIRCLE",
 574            "K/DA",
 575            "22/7",
 576            "諭吉佳作/men",
 577            "//dARTH nULL",
 578            "Phantom/Ghost",
 579            "She/Her/Hers",
 580            "5/8erl in Ehr'n",
 581            "Smith/Kotzen",
 582            "We;Na",
 583            "LSR/CITY",
 584        };
 85
 86        /// <summary>
 87        /// Transforms a FFprobe response into its <see cref="MediaInfo"/> equivalent.
 88        /// </summary>
 89        /// <param name="data">The <see cref="InternalMediaInfoResult"/>.</param>
 90        /// <param name="videoType">The <see cref="VideoType"/>.</param>
 91        /// <param name="isAudio">A boolean indicating whether the media is audio.</param>
 92        /// <param name="path">Path to media file.</param>
 93        /// <param name="protocol">Path media protocol.</param>
 94        /// <returns>The <see cref="MediaInfo"/>.</returns>
 95        public MediaInfo GetMediaInfo(InternalMediaInfoResult data, VideoType? videoType, bool isAudio, string path, Med
 96        {
 1097            var info = new MediaInfo
 1098            {
 1099                Path = path,
 10100                Protocol = protocol,
 10101                VideoType = videoType
 10102            };
 103
 10104            FFProbeHelpers.NormalizeFFProbeResult(data);
 10105            SetSize(data, info);
 106
 10107            var internalStreams = data.Streams ?? Array.Empty<MediaStreamInfo>();
 108
 10109            info.MediaStreams = internalStreams.Select(s => GetMediaStream(isAudio, s, data.Format))
 10110                .Where(i => i is not null)
 10111                // Drop subtitle streams if we don't know the codec because it will just cause failures if we don't know
 10112                .Where(i => i.Type != MediaStreamType.Subtitle || !string.IsNullOrWhiteSpace(i.Codec))
 10113                .ToList();
 114
 10115            info.MediaAttachments = internalStreams.Select(GetMediaAttachment)
 10116                .Where(i => i is not null)
 10117                .ToList();
 118
 10119            if (data.Format is not null)
 120            {
 9121                info.Container = NormalizeFormat(data.Format.FormatName, info.MediaStreams);
 122
 9123                if (int.TryParse(data.Format.BitRate, CultureInfo.InvariantCulture, out var value))
 124                {
 9125                    info.Bitrate = value;
 126                }
 127            }
 128
 10129            var tags = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 10130            var tagStreamType = isAudio ? CodecType.Audio : CodecType.Video;
 131
 10132            var tagStream = data.Streams?.FirstOrDefault(i => i.CodecType == tagStreamType);
 133
 10134            if (tagStream?.Tags is not null)
 135            {
 48136                foreach (var (key, value) in tagStream.Tags)
 137                {
 17138                    tags[key] = value;
 139                }
 140            }
 141
 10142            if (data.Format?.Tags is not null)
 143            {
 246144                foreach (var (key, value) in data.Format.Tags)
 145                {
 116146                    tags[key] = value;
 147                }
 148            }
 149
 10150            FetchGenres(info, tags);
 151
 10152            info.Name = tags.GetFirstNotNullNorWhiteSpaceValue("title", "title-eng");
 10153            info.ForcedSortName = tags.GetFirstNotNullNorWhiteSpaceValue("sort_name", "title-sort", "titlesort");
 10154            info.Overview = tags.GetFirstNotNullNorWhiteSpaceValue("synopsis", "description", "desc");
 155
 10156            info.IndexNumber = FFProbeHelpers.GetDictionaryNumericValue(tags, "episode_sort");
 10157            info.ParentIndexNumber = FFProbeHelpers.GetDictionaryNumericValue(tags, "season_number");
 10158            info.ShowName = tags.GetValueOrDefault("show_name");
 10159            info.ProductionYear = FFProbeHelpers.GetDictionaryNumericValue(tags, "date");
 160
 161            // Several different forms of retail/premiere date
 10162            info.PremiereDate =
 10163                FFProbeHelpers.GetDictionaryDateTime(tags, "originaldate") ??
 10164                FFProbeHelpers.GetDictionaryDateTime(tags, "retaildate") ??
 10165                FFProbeHelpers.GetDictionaryDateTime(tags, "retail date") ??
 10166                FFProbeHelpers.GetDictionaryDateTime(tags, "retail_date") ??
 10167                FFProbeHelpers.GetDictionaryDateTime(tags, "date_released") ??
 10168                FFProbeHelpers.GetDictionaryDateTime(tags, "date") ??
 10169                FFProbeHelpers.GetDictionaryDateTime(tags, "creation_time");
 170
 171            // Set common metadata for music (audio) and music videos (video)
 10172            info.Album = tags.GetValueOrDefault("album");
 173
 10174            if (tags.TryGetValue("artists", out var artists) && !string.IsNullOrWhiteSpace(artists))
 175            {
 2176                info.Artists = SplitDistinctArtists(artists, new[] { '/', ';' }, false).ToArray();
 177            }
 178            else
 179            {
 8180                var artist = tags.GetFirstNotNullNorWhiteSpaceValue("artist");
 8181                info.Artists = artist is null
 8182                    ? Array.Empty<string>()
 8183                    : SplitDistinctArtists(artist, _nameDelimiters, true).ToArray();
 184            }
 185
 186            // Guess ProductionYear from PremiereDate if missing
 10187            if (!info.ProductionYear.HasValue && info.PremiereDate.HasValue)
 188            {
 5189                info.ProductionYear = info.PremiereDate.Value.Year;
 190            }
 191
 192            // Set mediaType-specific metadata
 10193            if (isAudio)
 194            {
 2195                SetAudioRuntimeTicks(data, info);
 196
 197                // tags are normally located under data.format, but we've seen some cases with ogg where they're part of
 198                // so let's create a combined list of both
 199
 2200                SetAudioInfoFromTags(info, tags);
 201            }
 202            else
 203            {
 8204                FetchStudios(info, tags, "copyright");
 205
 8206                var iTunExtc = tags.GetFirstNotNullNorWhiteSpaceValue("iTunEXTC");
 8207                if (iTunExtc is not null)
 208                {
 0209                    var parts = iTunExtc.Split('|', StringSplitOptions.RemoveEmptyEntries);
 210                    // Example
 211                    // mpaa|G|100|For crude humor
 0212                    if (parts.Length > 1)
 213                    {
 0214                        info.OfficialRating = parts[1];
 215
 0216                        if (parts.Length > 3)
 217                        {
 0218                            info.OfficialRatingDescription = parts[3];
 219                        }
 220                    }
 221                }
 222
 8223                var iTunXml = tags.GetFirstNotNullNorWhiteSpaceValue("iTunMOVI");
 8224                if (iTunXml is not null)
 225                {
 1226                    FetchFromItunesInfo(iTunXml, info);
 227                }
 228
 8229                if (data.Format is not null && !string.IsNullOrEmpty(data.Format.Duration))
 230                {
 7231                    info.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(data.Format.Duration, CultureInfo.InvariantCul
 232                }
 233
 8234                FetchWtvInfo(info, data);
 235
 8236                if (data.Chapters is not null)
 237                {
 2238                    info.Chapters = data.Chapters.Select(GetChapterInfo).ToArray();
 239                }
 240
 8241                ExtractTimestamp(info);
 242
 8243                if (tags.TryGetValue("stereo_mode", out var stereoMode) && string.Equals(stereoMode, "left_right", Strin
 244                {
 0245                    info.Video3DFormat = Video3DFormat.FullSideBySide;
 246                }
 247
 54248                foreach (var mediaStream in info.MediaStreams)
 249                {
 19250                    if (mediaStream.Type == MediaStreamType.Audio && !mediaStream.BitRate.HasValue)
 251                    {
 3252                        mediaStream.BitRate = GetEstimatedAudioBitrate(mediaStream.Codec, mediaStream.Channels);
 253                    }
 254                }
 255
 8256                var videoStreamsBitrate = info.MediaStreams.Where(i => i.Type == MediaStreamType.Video).Select(i => i.Bi
 257                // If ffprobe reported the container bitrate as being the same as the video stream bitrate, then it's wr
 8258                if (videoStreamsBitrate == (info.Bitrate ?? 0))
 259                {
 4260                    info.InferTotalBitrate(true);
 261                }
 262            }
 263
 10264            return info;
 265        }
 266
 267        private string NormalizeFormat(string format, IReadOnlyList<MediaStream> mediaStreams)
 268        {
 9269            if (string.IsNullOrWhiteSpace(format))
 270            {
 0271                return null;
 272            }
 273
 274            // Input can be a list of multiple, comma-delimited formats - each of them needs to be checked
 9275            var splitFormat = format.Split(',');
 72276            for (var i = 0; i < splitFormat.Length; i++)
 277            {
 278                // Handle MPEG-1 container
 27279                if (string.Equals(splitFormat[i], "mpegvideo", StringComparison.OrdinalIgnoreCase))
 280                {
 0281                    splitFormat[i] = "mpeg";
 282                }
 283
 284                // Handle MPEG-TS container
 27285                else if (string.Equals(splitFormat[i], "mpegts", StringComparison.OrdinalIgnoreCase))
 286                {
 1287                    splitFormat[i] = "ts";
 288                }
 289
 290                // Handle matroska container
 26291                else if (string.Equals(splitFormat[i], "matroska", StringComparison.OrdinalIgnoreCase))
 292                {
 3293                    splitFormat[i] = "mkv";
 294                }
 295
 296                // Handle WebM
 23297                else if (string.Equals(splitFormat[i], "webm", StringComparison.OrdinalIgnoreCase))
 298                {
 299                    // Limit WebM to supported codecs
 3300                    if (mediaStreams.Any(stream => (stream.Type == MediaStreamType.Video && !_webmVideoCodecs.Contains(s
 3301                        || (stream.Type == MediaStreamType.Audio && !_webmAudioCodecs.Contains(stream.Codec, StringCompa
 302                    {
 2303                        splitFormat[i] = string.Empty;
 304                    }
 305                }
 306            }
 307
 9308            return string.Join(',', splitFormat.Where(s => !string.IsNullOrEmpty(s)));
 309        }
 310
 311        private int? GetEstimatedAudioBitrate(string codec, int? channels)
 312        {
 3313            if (!channels.HasValue)
 314            {
 0315                return null;
 316            }
 317
 3318            var channelsValue = channels.Value;
 319
 3320            if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase)
 3321                || string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
 322            {
 323                switch (channelsValue)
 324                {
 325                    case <= 2:
 1326                        return 192000;
 327                    case >= 5:
 0328                        return 320000;
 329                }
 330            }
 331
 2332            if (string.Equals(codec, "ac3", StringComparison.OrdinalIgnoreCase)
 2333                || string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))
 334            {
 335                switch (channelsValue)
 336                {
 337                    case <= 2:
 0338                        return 192000;
 339                    case >= 5:
 0340                        return 640000;
 341                }
 342            }
 343
 2344            if (string.Equals(codec, "flac", StringComparison.OrdinalIgnoreCase)
 2345                || string.Equals(codec, "alac", StringComparison.OrdinalIgnoreCase))
 346            {
 347                switch (channelsValue)
 348                {
 349                    case <= 2:
 0350                        return 960000;
 351                    case >= 5:
 0352                        return 2880000;
 353                }
 354            }
 355
 2356            return null;
 357        }
 358
 359        private void FetchFromItunesInfo(string xml, MediaInfo info)
 360        {
 361            // Make things simpler and strip out the dtd
 1362            var plistIndex = xml.IndexOf("<plist", StringComparison.OrdinalIgnoreCase);
 363
 1364            if (plistIndex != -1)
 365            {
 1366                xml = xml.Substring(plistIndex);
 367            }
 368
 1369            xml = "<?xml version=\"1.0\"?>" + xml;
 370
 371            // <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http
 1372            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
 1373            using (var streamReader = new StreamReader(stream))
 374            {
 375                try
 376                {
 1377                    using (var reader = XmlReader.Create(streamReader))
 378                    {
 1379                        reader.MoveToContent();
 1380                        reader.Read();
 381
 382                        // Loop through each element
 4383                        while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 384                        {
 3385                            if (reader.NodeType == XmlNodeType.Element)
 386                            {
 1387                                switch (reader.Name)
 388                                {
 389                                    case "dict":
 1390                                        if (reader.IsEmptyElement)
 391                                        {
 0392                                            reader.Read();
 0393                                            continue;
 394                                        }
 395
 1396                                        using (var subtree = reader.ReadSubtree())
 397                                        {
 1398                                            ReadFromDictNode(subtree, info);
 1399                                        }
 400
 401                                        break;
 402                                    default:
 0403                                        reader.Skip();
 0404                                        break;
 405                                }
 406                            }
 407                            else
 408                            {
 2409                                reader.Read();
 410                            }
 411                        }
 1412                    }
 1413                }
 0414                catch (XmlException)
 415                {
 416                    // I've seen probe examples where the iTunMOVI value is just "<"
 417                    // So we should not allow this to fail the entire probing operation
 0418                }
 419            }
 1420        }
 421
 422        private void ReadFromDictNode(XmlReader reader, MediaInfo info)
 423        {
 1424            string currentKey = null;
 1425            var pairs = new List<NameValuePair>();
 426
 1427            reader.MoveToContent();
 1428            reader.Read();
 429
 430            // Loop through each element
 19431            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 432            {
 18433                if (reader.NodeType == XmlNodeType.Element)
 434                {
 12435                    switch (reader.Name)
 436                    {
 437                        case "key":
 6438                            if (!string.IsNullOrWhiteSpace(currentKey))
 439                            {
 5440                                ProcessPairs(currentKey, pairs, info);
 441                            }
 442
 6443                            currentKey = reader.ReadElementContentAsString();
 6444                            pairs = new List<NameValuePair>();
 6445                            break;
 446                        case "string":
 1447                            var value = reader.ReadElementContentAsString();
 1448                            if (!string.IsNullOrWhiteSpace(value))
 449                            {
 1450                                pairs.Add(new NameValuePair
 1451                                {
 1452                                    Name = value,
 1453                                    Value = value
 1454                                });
 455                            }
 456
 1457                            break;
 458                        case "array":
 5459                            if (reader.IsEmptyElement)
 460                            {
 0461                                reader.Read();
 0462                                continue;
 463                            }
 464
 5465                            using (var subtree = reader.ReadSubtree())
 466                            {
 5467                                if (!string.IsNullOrWhiteSpace(currentKey))
 468                                {
 5469                                    pairs.AddRange(ReadValueArray(subtree));
 470                                }
 5471                            }
 472
 473                            break;
 474                        default:
 0475                            reader.Skip();
 0476                            break;
 477                    }
 478                }
 479                else
 480                {
 6481                    reader.Read();
 482                }
 483            }
 1484        }
 485
 486        private List<NameValuePair> ReadValueArray(XmlReader reader)
 487        {
 5488            var pairs = new List<NameValuePair>();
 489
 5490            reader.MoveToContent();
 5491            reader.Read();
 492
 493            // Loop through each element
 20494            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 495            {
 15496                if (reader.NodeType == XmlNodeType.Element)
 497                {
 5498                    switch (reader.Name)
 499                    {
 500                        case "dict":
 501
 5502                            if (reader.IsEmptyElement)
 503                            {
 0504                                reader.Read();
 0505                                continue;
 506                            }
 507
 5508                            using (var subtree = reader.ReadSubtree())
 509                            {
 5510                                var dict = GetNameValuePair(subtree);
 5511                                if (dict is not null)
 512                                {
 1513                                    pairs.Add(dict);
 514                                }
 5515                            }
 516
 517                            break;
 518                        default:
 0519                            reader.Skip();
 0520                            break;
 521                    }
 522                }
 523                else
 524                {
 10525                    reader.Read();
 526                }
 527            }
 528
 5529            return pairs;
 530        }
 531
 532        private void ProcessPairs(string key, List<NameValuePair> pairs, MediaInfo info)
 533        {
 5534            List<BaseItemPerson> peoples = new List<BaseItemPerson>();
 5535            var distinctPairs = pairs.Select(p => p.Value)
 5536                    .Where(i => !string.IsNullOrWhiteSpace(i))
 5537                    .Trimmed()
 5538                    .Distinct(StringComparer.OrdinalIgnoreCase);
 539
 5540            if (string.Equals(key, "studio", StringComparison.OrdinalIgnoreCase))
 541            {
 1542                info.Studios = distinctPairs.ToArray();
 543            }
 4544            else if (string.Equals(key, "screenwriters", StringComparison.OrdinalIgnoreCase))
 545            {
 0546                foreach (var pair in distinctPairs)
 547                {
 0548                    peoples.Add(new BaseItemPerson
 0549                    {
 0550                        Name = pair,
 0551                        Type = PersonKind.Writer
 0552                    });
 553                }
 554            }
 4555            else if (string.Equals(key, "producers", StringComparison.OrdinalIgnoreCase))
 556            {
 2557                foreach (var pair in distinctPairs)
 558                {
 0559                    peoples.Add(new BaseItemPerson
 0560                    {
 0561                        Name = pair,
 0562                        Type = PersonKind.Producer
 0563                    });
 564                }
 565            }
 3566            else if (string.Equals(key, "directors", StringComparison.OrdinalIgnoreCase))
 567            {
 2568                foreach (var pair in distinctPairs)
 569                {
 0570                    peoples.Add(new BaseItemPerson
 0571                    {
 0572                        Name = pair,
 0573                        Type = PersonKind.Director
 0574                    });
 575                }
 576            }
 577
 5578            info.People = peoples.ToArray();
 5579        }
 580
 581        private NameValuePair GetNameValuePair(XmlReader reader)
 582        {
 5583            string name = null;
 5584            string value = null;
 585
 5586            reader.MoveToContent();
 5587            reader.Read();
 588
 589            // Loop through each element
 20590            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 591            {
 15592                if (reader.NodeType == XmlNodeType.Element)
 593                {
 10594                    switch (reader.Name)
 595                    {
 596                        case "key":
 5597                            name = reader.ReadNormalizedString();
 5598                            break;
 599                        case "string":
 5600                            value = reader.ReadNormalizedString();
 5601                            break;
 602                        default:
 0603                            reader.Skip();
 0604                            break;
 605                    }
 606                }
 607                else
 608                {
 5609                    reader.Read();
 610                }
 611            }
 612
 5613            if (string.IsNullOrEmpty(name)
 5614                || string.IsNullOrEmpty(value))
 615            {
 4616                return null;
 617            }
 618
 1619            return new NameValuePair
 1620            {
 1621                Name = name,
 1622                Value = value
 1623            };
 624        }
 625
 626        private string NormalizeSubtitleCodec(string codec)
 627        {
 3628            if (string.Equals(codec, "dvb_subtitle", StringComparison.OrdinalIgnoreCase))
 629            {
 0630                codec = "DVBSUB";
 631            }
 3632            else if (string.Equals(codec, "dvb_teletext", StringComparison.OrdinalIgnoreCase))
 633            {
 0634                codec = "DVBTXT";
 635            }
 3636            else if (string.Equals(codec, "dvd_subtitle", StringComparison.OrdinalIgnoreCase))
 637            {
 1638                codec = "DVDSUB"; // .sub+.idx
 639            }
 2640            else if (string.Equals(codec, "hdmv_pgs_subtitle", StringComparison.OrdinalIgnoreCase))
 641            {
 0642                codec = "PGSSUB"; // .sup
 643            }
 644
 3645            return codec;
 646        }
 647
 648        /// <summary>
 649        /// Converts ffprobe stream info to our MediaAttachment class.
 650        /// </summary>
 651        /// <param name="streamInfo">The stream info.</param>
 652        /// <returns>MediaAttachments.</returns>
 653        private MediaAttachment GetMediaAttachment(MediaStreamInfo streamInfo)
 654        {
 23655            if (streamInfo.CodecType != CodecType.Attachment
 23656                && streamInfo.Disposition?.GetValueOrDefault("attached_pic") != 1)
 657            {
 21658                return null;
 659            }
 660
 2661            var attachment = new MediaAttachment
 2662            {
 2663                Codec = streamInfo.CodecName,
 2664                Index = streamInfo.Index
 2665            };
 666
 2667            if (!string.IsNullOrWhiteSpace(streamInfo.CodecTagString))
 668            {
 2669                attachment.CodecTag = streamInfo.CodecTagString;
 670            }
 671
 2672            if (streamInfo.Tags is not null)
 673            {
 2674                attachment.FileName = GetDictionaryValue(streamInfo.Tags, "filename");
 2675                attachment.MimeType = GetDictionaryValue(streamInfo.Tags, "mimetype");
 2676                attachment.Comment = GetDictionaryValue(streamInfo.Tags, "comment");
 677            }
 678
 2679            return attachment;
 680        }
 681
 682        /// <summary>
 683        /// Converts ffprobe stream info to our MediaStream class.
 684        /// </summary>
 685        /// <param name="isAudio">if set to <c>true</c> [is info].</param>
 686        /// <param name="streamInfo">The stream info.</param>
 687        /// <param name="formatInfo">The format info.</param>
 688        /// <returns>MediaStream.</returns>
 689        private MediaStream GetMediaStream(bool isAudio, MediaStreamInfo streamInfo, MediaFormatInfo formatInfo)
 690        {
 691            // These are mp4 chapters
 23692            if (string.Equals(streamInfo.CodecName, "mov_text", StringComparison.OrdinalIgnoreCase))
 693            {
 694                // Edit: but these are also sometimes subtitles?
 695                // return null;
 696            }
 697
 23698            var stream = new MediaStream
 23699            {
 23700                Codec = streamInfo.CodecName,
 23701                Profile = streamInfo.Profile,
 23702                Level = streamInfo.Level,
 23703                Index = streamInfo.Index,
 23704                PixelFormat = streamInfo.PixelFormat,
 23705                NalLengthSize = streamInfo.NalLengthSize,
 23706                TimeBase = streamInfo.TimeBase,
 23707                CodecTimeBase = streamInfo.CodecTimeBase,
 23708                IsAVC = streamInfo.IsAvc
 23709            };
 710
 711            // Filter out junk
 23712            if (!string.IsNullOrWhiteSpace(streamInfo.CodecTagString) && !streamInfo.CodecTagString.Contains("[0]", Stri
 713            {
 10714                stream.CodecTag = streamInfo.CodecTagString;
 715            }
 716
 23717            if (streamInfo.Tags is not null)
 718            {
 19719                stream.Language = GetDictionaryValue(streamInfo.Tags, "language");
 19720                stream.Comment = GetDictionaryValue(streamInfo.Tags, "comment");
 19721                stream.Title = GetDictionaryValue(streamInfo.Tags, "title");
 722            }
 723
 23724            if (streamInfo.CodecType == CodecType.Audio)
 725            {
 10726                stream.Type = MediaStreamType.Audio;
 10727                stream.LocalizedDefault = _localization.GetLocalizedString("Default");
 10728                stream.LocalizedExternal = _localization.GetLocalizedString("External");
 729
 10730                stream.Channels = streamInfo.Channels;
 731
 10732                if (int.TryParse(streamInfo.SampleRate, CultureInfo.InvariantCulture, out var sampleRate))
 733                {
 10734                    stream.SampleRate = sampleRate;
 735                }
 736
 10737                stream.ChannelLayout = ParseChannelLayout(streamInfo.ChannelLayout);
 738
 10739                if (streamInfo.BitsPerSample > 0)
 740                {
 0741                    stream.BitDepth = streamInfo.BitsPerSample;
 742                }
 10743                else if (streamInfo.BitsPerRawSample > 0)
 744                {
 3745                    stream.BitDepth = streamInfo.BitsPerRawSample;
 746                }
 747
 10748                if (string.IsNullOrEmpty(stream.Title))
 749                {
 750                    // mp4 missing track title workaround: fall back to handler_name if populated and not the default "S
 10751                    string handlerName = GetDictionaryValue(streamInfo.Tags, "handler_name");
 10752                    if (!string.IsNullOrEmpty(handlerName) && !string.Equals(handlerName, "SoundHandler", StringComparis
 753                    {
 3754                        stream.Title = handlerName;
 755                    }
 756                }
 757            }
 13758            else if (streamInfo.CodecType == CodecType.Subtitle)
 759            {
 3760                stream.Type = MediaStreamType.Subtitle;
 3761                stream.Codec = NormalizeSubtitleCodec(stream.Codec);
 3762                stream.LocalizedUndefined = _localization.GetLocalizedString("Undefined");
 3763                stream.LocalizedDefault = _localization.GetLocalizedString("Default");
 3764                stream.LocalizedForced = _localization.GetLocalizedString("Forced");
 3765                stream.LocalizedExternal = _localization.GetLocalizedString("External");
 3766                stream.LocalizedHearingImpaired = _localization.GetLocalizedString("HearingImpaired");
 767
 768                // Graphical subtitle may have width and height info
 3769                stream.Width = streamInfo.Width;
 3770                stream.Height = streamInfo.Height;
 771
 3772                if (string.IsNullOrEmpty(stream.Title))
 773                {
 774                    // mp4 missing track title workaround: fall back to handler_name if populated and not the default "S
 3775                    string handlerName = GetDictionaryValue(streamInfo.Tags, "handler_name");
 3776                    if (!string.IsNullOrEmpty(handlerName) && !string.Equals(handlerName, "SubtitleHandler", StringCompa
 777                    {
 1778                        stream.Title = handlerName;
 779                    }
 780                }
 781            }
 10782            else if (streamInfo.CodecType == CodecType.Video)
 783            {
 10784                stream.AverageFrameRate = GetFrameRate(streamInfo.AverageFrameRate);
 10785                stream.RealFrameRate = GetFrameRate(streamInfo.RFrameRate);
 786
 10787                stream.IsInterlaced = !string.IsNullOrWhiteSpace(streamInfo.FieldOrder)
 10788                    && !string.Equals(streamInfo.FieldOrder, "progressive", StringComparison.OrdinalIgnoreCase);
 789
 10790                if (isAudio
 10791                    || string.Equals(stream.Codec, "bmp", StringComparison.OrdinalIgnoreCase)
 10792                    || string.Equals(stream.Codec, "gif", StringComparison.OrdinalIgnoreCase)
 10793                    || string.Equals(stream.Codec, "png", StringComparison.OrdinalIgnoreCase)
 10794                    || string.Equals(stream.Codec, "webp", StringComparison.OrdinalIgnoreCase))
 795                {
 2796                    stream.Type = MediaStreamType.EmbeddedImage;
 797                }
 8798                else if (string.Equals(stream.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase))
 799                {
 800                    // How to differentiate between video and embedded image?
 801                    // The only difference I've seen thus far is presence of codec tag, also embedded images have high (
 0802                    if (!string.IsNullOrWhiteSpace(stream.CodecTag))
 803                    {
 0804                        stream.Type = MediaStreamType.Video;
 805                    }
 806                    else
 807                    {
 0808                        stream.Type = MediaStreamType.EmbeddedImage;
 809                    }
 810                }
 811                else
 812                {
 8813                    stream.Type = MediaStreamType.Video;
 814                }
 815
 10816                stream.Width = streamInfo.Width;
 10817                stream.Height = streamInfo.Height;
 10818                stream.AspectRatio = GetAspectRatio(streamInfo);
 819
 10820                if (streamInfo.BitsPerSample > 0)
 821                {
 0822                    stream.BitDepth = streamInfo.BitsPerSample;
 823                }
 10824                else if (streamInfo.BitsPerRawSample > 0)
 825                {
 9826                    stream.BitDepth = streamInfo.BitsPerRawSample;
 827                }
 828
 10829                if (!stream.BitDepth.HasValue)
 830                {
 1831                    if (!string.IsNullOrEmpty(streamInfo.PixelFormat))
 832                    {
 1833                        if (string.Equals(streamInfo.PixelFormat, "yuv420p", StringComparison.OrdinalIgnoreCase)
 1834                            || string.Equals(streamInfo.PixelFormat, "yuv444p", StringComparison.OrdinalIgnoreCase))
 835                        {
 1836                            stream.BitDepth = 8;
 837                        }
 0838                        else if (string.Equals(streamInfo.PixelFormat, "yuv420p10le", StringComparison.OrdinalIgnoreCase
 0839                                 || string.Equals(streamInfo.PixelFormat, "yuv444p10le", StringComparison.OrdinalIgnoreC
 840                        {
 0841                            stream.BitDepth = 10;
 842                        }
 0843                        else if (string.Equals(streamInfo.PixelFormat, "yuv420p12le", StringComparison.OrdinalIgnoreCase
 0844                                 || string.Equals(streamInfo.PixelFormat, "yuv444p12le", StringComparison.OrdinalIgnoreC
 845                        {
 0846                            stream.BitDepth = 12;
 847                        }
 848                    }
 849                }
 850
 851                // stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIg
 852                //    string.Equals(stream.AspectRatio, "2.35:1", StringComparison.OrdinalIgnoreCase) ||
 853                //    string.Equals(stream.AspectRatio, "2.40:1", StringComparison.OrdinalIgnoreCase);
 854
 855                // http://stackoverflow.com/questions/17353387/how-to-detect-anamorphic-video-with-ffprobe
 10856                stream.IsAnamorphic = string.Equals(streamInfo.SampleAspectRatio, "0:1", StringComparison.OrdinalIgnoreC
 857
 10858                if (streamInfo.Refs > 0)
 859                {
 10860                    stream.RefFrames = streamInfo.Refs;
 861                }
 862
 10863                if (!string.IsNullOrEmpty(streamInfo.ColorRange))
 864                {
 4865                    stream.ColorRange = streamInfo.ColorRange;
 866                }
 867
 10868                if (!string.IsNullOrEmpty(streamInfo.ColorSpace))
 869                {
 4870                    stream.ColorSpace = streamInfo.ColorSpace;
 871                }
 872
 10873                if (!string.IsNullOrEmpty(streamInfo.ColorTransfer))
 874                {
 2875                    stream.ColorTransfer = streamInfo.ColorTransfer;
 876                }
 877
 10878                if (!string.IsNullOrEmpty(streamInfo.ColorPrimaries))
 879                {
 2880                    stream.ColorPrimaries = streamInfo.ColorPrimaries;
 881                }
 882
 10883                if (streamInfo.SideDataList is not null)
 884                {
 6885                    foreach (var data in streamInfo.SideDataList)
 886                    {
 887                        // Parse Dolby Vision metadata from side_data
 2888                        if (string.Equals(data.SideDataType, "DOVI configuration record", StringComparison.OrdinalIgnore
 889                        {
 1890                            stream.DvVersionMajor = data.DvVersionMajor;
 1891                            stream.DvVersionMinor = data.DvVersionMinor;
 1892                            stream.DvProfile = data.DvProfile;
 1893                            stream.DvLevel = data.DvLevel;
 1894                            stream.RpuPresentFlag = data.RpuPresentFlag;
 1895                            stream.ElPresentFlag = data.ElPresentFlag;
 1896                            stream.BlPresentFlag = data.BlPresentFlag;
 1897                            stream.DvBlSignalCompatibilityId = data.DvBlSignalCompatibilityId;
 898                        }
 899
 900                        // Parse video rotation metadata from side_data
 1901                        else if (string.Equals(data.SideDataType, "Display Matrix", StringComparison.OrdinalIgnoreCase))
 902                        {
 1903                            stream.Rotation = data.Rotation;
 904                        }
 905                    }
 906                }
 907            }
 0908            else if (streamInfo.CodecType == CodecType.Data)
 909            {
 0910                stream.Type = MediaStreamType.Data;
 911            }
 912            else
 913            {
 0914                return null;
 915            }
 916
 917            // Get stream bitrate
 23918            var bitrate = 0;
 919
 23920            if (int.TryParse(streamInfo.BitRate, CultureInfo.InvariantCulture, out var value))
 921            {
 12922                bitrate = value;
 923            }
 924
 925            // The bitrate info of FLAC musics and some videos is included in formatInfo.
 23926            if (bitrate == 0
 23927                && formatInfo is not null
 23928                && (stream.Type == MediaStreamType.Video || (isAudio && stream.Type == MediaStreamType.Audio)))
 929            {
 930                // If the stream info doesn't have a bitrate get the value from the media format info
 6931                if (int.TryParse(formatInfo.BitRate, CultureInfo.InvariantCulture, out value))
 932                {
 6933                    bitrate = value;
 934                }
 935            }
 936
 23937            if (bitrate > 0)
 938            {
 18939                stream.BitRate = bitrate;
 940            }
 941
 942            // Extract bitrate info from tag "BPS" if possible.
 23943            if (!stream.BitRate.HasValue
 23944                && (streamInfo.CodecType == CodecType.Audio
 23945                    || streamInfo.CodecType == CodecType.Video))
 946            {
 5947                var bps = GetBPSFromTags(streamInfo);
 5948                if (bps > 0)
 949                {
 0950                    stream.BitRate = bps;
 951                }
 952                else
 953                {
 954                    // Get average bitrate info from tag "NUMBER_OF_BYTES" and "DURATION" if possible.
 5955                    var durationInSeconds = GetRuntimeSecondsFromTags(streamInfo);
 5956                    var bytes = GetNumberOfBytesFromTags(streamInfo);
 5957                    if (durationInSeconds is not null && bytes is not null)
 958                    {
 0959                        bps = Convert.ToInt32(bytes * 8 / durationInSeconds, CultureInfo.InvariantCulture);
 0960                        if (bps > 0)
 961                        {
 0962                            stream.BitRate = bps;
 963                        }
 964                    }
 965                }
 966            }
 967
 23968            var disposition = streamInfo.Disposition;
 23969            if (disposition is not null)
 970            {
 23971                if (disposition.GetValueOrDefault("default") == 1)
 972                {
 13973                    stream.IsDefault = true;
 974                }
 975
 23976                if (disposition.GetValueOrDefault("forced") == 1)
 977                {
 0978                    stream.IsForced = true;
 979                }
 980
 23981                if (disposition.GetValueOrDefault("hearing_impaired") == 1)
 982                {
 1983                    stream.IsHearingImpaired = true;
 984                }
 985            }
 986
 23987            NormalizeStreamTitle(stream);
 988
 23989            return stream;
 990        }
 991
 992        private void NormalizeStreamTitle(MediaStream stream)
 993        {
 23994            if (string.Equals(stream.Title, "cc", StringComparison.OrdinalIgnoreCase)
 23995                || stream.Type == MediaStreamType.EmbeddedImage)
 996            {
 2997                stream.Title = null;
 998            }
 23999        }
 1000
 1001        /// <summary>
 1002        /// Gets a string from an FFProbeResult tags dictionary.
 1003        /// </summary>
 1004        /// <param name="tags">The tags.</param>
 1005        /// <param name="key">The key.</param>
 1006        /// <returns>System.String.</returns>
 1007        private string GetDictionaryValue(IReadOnlyDictionary<string, string> tags, string key)
 1008        {
 1061009            if (tags is null)
 1010            {
 31011                return null;
 1012            }
 1013
 1031014            tags.TryGetValue(key, out var val);
 1015
 1031016            return val;
 1017        }
 1018
 1019        private string ParseChannelLayout(string input)
 1020        {
 101021            if (string.IsNullOrEmpty(input))
 1022            {
 11023                return null;
 1024            }
 1025
 91026            return input.AsSpan().LeftPart('(').ToString();
 1027        }
 1028
 1029        private string GetAspectRatio(MediaStreamInfo info)
 1030        {
 101031            var original = info.DisplayAspectRatio;
 1032
 101033            var parts = (original ?? string.Empty).Split(':');
 101034            if (!(parts.Length == 2
 101035                    && int.TryParse(parts[0], CultureInfo.InvariantCulture, out var width)
 101036                    && int.TryParse(parts[1], CultureInfo.InvariantCulture, out var height)
 101037                    && width > 0
 101038                    && height > 0))
 1039            {
 31040                width = info.Width;
 31041                height = info.Height;
 1042            }
 1043
 101044            if (width > 0 && height > 0)
 1045            {
 101046                double ratio = width;
 101047                ratio /= height;
 1048
 101049                if (IsClose(ratio, 1.777777778, .03))
 1050                {
 51051                    return "16:9";
 1052                }
 1053
 51054                if (IsClose(ratio, 1.3333333333, .05))
 1055                {
 11056                    return "4:3";
 1057                }
 1058
 41059                if (IsClose(ratio, 1.41))
 1060                {
 01061                    return "1.41:1";
 1062                }
 1063
 41064                if (IsClose(ratio, 1.5))
 1065                {
 11066                    return "1.5:1";
 1067                }
 1068
 31069                if (IsClose(ratio, 1.6))
 1070                {
 01071                    return "1.6:1";
 1072                }
 1073
 31074                if (IsClose(ratio, 1.66666666667))
 1075                {
 01076                    return "5:3";
 1077                }
 1078
 31079                if (IsClose(ratio, 1.85, .02))
 1080                {
 01081                    return "1.85:1";
 1082                }
 1083
 31084                if (IsClose(ratio, 2.35, .025))
 1085                {
 01086                    return "2.35:1";
 1087                }
 1088
 31089                if (IsClose(ratio, 2.4, .025))
 1090                {
 11091                    return "2.40:1";
 1092                }
 1093            }
 1094
 21095            return original;
 1096        }
 1097
 1098        private bool IsClose(double d1, double d2, double variance = .005)
 1099        {
 381100            return Math.Abs(d1 - d2) <= variance;
 1101        }
 1102
 1103        /// <summary>
 1104        /// Gets a frame rate from a string value in ffprobe output
 1105        /// This could be a number or in the format of 2997/125.
 1106        /// </summary>
 1107        /// <param name="value">The value.</param>
 1108        /// <returns>System.Nullable{System.Single}.</returns>
 1109        internal static float? GetFrameRate(ReadOnlySpan<char> value)
 1110        {
 291111            if (value.IsEmpty)
 1112            {
 01113                return null;
 1114            }
 1115
 291116            int index = value.IndexOf('/');
 291117            if (index == -1)
 1118            {
 01119                return null;
 1120            }
 1121
 291122            if (!float.TryParse(value[..index], NumberStyles.Integer, CultureInfo.InvariantCulture, out var dividend)
 291123                || !float.TryParse(value[(index + 1)..], NumberStyles.Integer, CultureInfo.InvariantCulture, out var div
 1124            {
 01125                return null;
 1126            }
 1127
 291128            return divisor == 0f ? null : dividend / divisor;
 1129        }
 1130
 1131        private void SetAudioRuntimeTicks(InternalMediaInfoResult result, MediaInfo data)
 1132        {
 1133            // Get the first info stream
 21134            var stream = result.Streams?.FirstOrDefault(s => s.CodecType == CodecType.Audio);
 21135            if (stream is null)
 1136            {
 01137                return;
 1138            }
 1139
 1140            // Get duration from stream properties
 21141            var duration = stream.Duration;
 1142
 1143            // If it's not there go into format properties
 21144            if (string.IsNullOrEmpty(duration))
 1145            {
 01146                duration = result.Format.Duration;
 1147            }
 1148
 1149            // If we got something, parse it
 21150            if (!string.IsNullOrEmpty(duration))
 1151            {
 21152                data.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(duration, CultureInfo.InvariantCulture)).Ticks;
 1153            }
 21154        }
 1155
 1156        private int? GetBPSFromTags(MediaStreamInfo streamInfo)
 1157        {
 51158            if (streamInfo?.Tags is null)
 1159            {
 01160                return null;
 1161            }
 1162
 51163            var bps = GetDictionaryValue(streamInfo.Tags, "BPS-eng") ?? GetDictionaryValue(streamInfo.Tags, "BPS");
 51164            if (int.TryParse(bps, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedBps))
 1165            {
 01166                return parsedBps;
 1167            }
 1168
 51169            return null;
 1170        }
 1171
 1172        private double? GetRuntimeSecondsFromTags(MediaStreamInfo streamInfo)
 1173        {
 51174            if (streamInfo?.Tags is null)
 1175            {
 01176                return null;
 1177            }
 1178
 51179            var duration = GetDictionaryValue(streamInfo.Tags, "DURATION-eng") ?? GetDictionaryValue(streamInfo.Tags, "D
 51180            if (TimeSpan.TryParse(duration, out var parsedDuration))
 1181            {
 01182                return parsedDuration.TotalSeconds;
 1183            }
 1184
 51185            return null;
 1186        }
 1187
 1188        private long? GetNumberOfBytesFromTags(MediaStreamInfo streamInfo)
 1189        {
 51190            if (streamInfo?.Tags is null)
 1191            {
 01192                return null;
 1193            }
 1194
 51195            var numberOfBytes = GetDictionaryValue(streamInfo.Tags, "NUMBER_OF_BYTES-eng")
 51196                                ?? GetDictionaryValue(streamInfo.Tags, "NUMBER_OF_BYTES");
 51197            if (long.TryParse(numberOfBytes, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedBytes))
 1198            {
 01199                return parsedBytes;
 1200            }
 1201
 51202            return null;
 1203        }
 1204
 1205        private void SetSize(InternalMediaInfoResult data, MediaInfo info)
 1206        {
 101207            if (data.Format is null)
 1208            {
 11209                return;
 1210            }
 1211
 91212            info.Size = string.IsNullOrEmpty(data.Format.Size) ? null : long.Parse(data.Format.Size, CultureInfo.Invaria
 91213        }
 1214
 1215        private void SetAudioInfoFromTags(MediaInfo audio, Dictionary<string, string> tags)
 1216        {
 21217            var people = new List<BaseItemPerson>();
 21218            if (tags.TryGetValue("composer", out var composer) && !string.IsNullOrWhiteSpace(composer))
 1219            {
 121220                foreach (var person in Split(composer, false))
 1221                {
 41222                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Composer });
 1223                }
 1224            }
 1225
 21226            if (tags.TryGetValue("conductor", out var conductor) && !string.IsNullOrWhiteSpace(conductor))
 1227            {
 01228                foreach (var person in Split(conductor, false))
 1229                {
 01230                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Conductor });
 1231                }
 1232            }
 1233
 21234            if (tags.TryGetValue("lyricist", out var lyricist) && !string.IsNullOrWhiteSpace(lyricist))
 1235            {
 81236                foreach (var person in Split(lyricist, false))
 1237                {
 21238                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Lyricist });
 1239                }
 1240            }
 1241
 21242            if (tags.TryGetValue("performer", out var performer) && !string.IsNullOrWhiteSpace(performer))
 1243            {
 501244                foreach (var person in Split(performer, false))
 1245                {
 231246                    Match match = PerformerRegex().Match(person);
 1247
 1248                    // If the performer doesn't have any instrument/role associated, it won't match. In that case, chanc
 231249                    if (match.Success)
 1250                    {
 221251                        people.Add(new BaseItemPerson
 221252                        {
 221253                            Name = match.Groups["name"].Value,
 221254                            Type = PersonKind.Actor,
 221255                            Role = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(match.Groups["instrument"].Value)
 221256                        });
 1257                    }
 1258                }
 1259            }
 1260
 1261            // In cases where there isn't sufficient information as to which role a writer performed on a recording, tag
 21262            if (tags.TryGetValue("writer", out var writer) && !string.IsNullOrWhiteSpace(writer))
 1263            {
 01264                foreach (var person in Split(writer, false))
 1265                {
 01266                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Writer });
 1267                }
 1268            }
 1269
 21270            if (tags.TryGetValue("arranger", out var arranger) && !string.IsNullOrWhiteSpace(arranger))
 1271            {
 121272                foreach (var person in Split(arranger, false))
 1273                {
 41274                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Arranger });
 1275                }
 1276            }
 1277
 21278            if (tags.TryGetValue("engineer", out var engineer) && !string.IsNullOrWhiteSpace(engineer))
 1279            {
 01280                foreach (var person in Split(engineer, false))
 1281                {
 01282                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Engineer });
 1283                }
 1284            }
 1285
 21286            if (tags.TryGetValue("mixer", out var mixer) && !string.IsNullOrWhiteSpace(mixer))
 1287            {
 81288                foreach (var person in Split(mixer, false))
 1289                {
 21290                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Mixer });
 1291                }
 1292            }
 1293
 21294            if (tags.TryGetValue("remixer", out var remixer) && !string.IsNullOrWhiteSpace(remixer))
 1295            {
 01296                foreach (var person in Split(remixer, false))
 1297                {
 01298                    people.Add(new BaseItemPerson { Name = person, Type = PersonKind.Remixer });
 1299                }
 1300            }
 1301
 21302            audio.People = people.ToArray();
 1303
 1304            // Set album artist
 21305            var albumArtist = tags.GetFirstNotNullNorWhiteSpaceValue("albumartist", "album artist", "album_artist");
 21306            audio.AlbumArtists = albumArtist is not null
 21307                ? SplitDistinctArtists(albumArtist, _nameDelimiters, true).ToArray()
 21308                : Array.Empty<string>();
 1309
 1310            // Set album artist to artist if empty
 21311            if (audio.AlbumArtists.Length == 0)
 1312            {
 01313                audio.AlbumArtists = audio.Artists;
 1314            }
 1315
 1316            // Track number
 21317            audio.IndexNumber = GetDictionaryTrackOrDiscNumber(tags, "track");
 1318
 1319            // Disc number
 21320            audio.ParentIndexNumber = GetDictionaryTrackOrDiscNumber(tags, "disc");
 1321
 1322            // There's several values in tags may or may not be present
 21323            FetchStudios(audio, tags, "organization");
 21324            FetchStudios(audio, tags, "ensemble");
 21325            FetchStudios(audio, tags, "publisher");
 21326            FetchStudios(audio, tags, "label");
 1327
 1328            // These support multiple values, but for now we only store the first.
 21329            var mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Album Artist Id"))
 21330                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ALBUMARTISTID"));
 21331            audio.TrySetProviderId(MetadataProvider.MusicBrainzAlbumArtist, mb);
 1332
 21333            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Artist Id"))
 21334                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ARTISTID"));
 21335            audio.TrySetProviderId(MetadataProvider.MusicBrainzArtist, mb);
 1336
 21337            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Album Id"))
 21338                ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_ALBUMID"));
 21339            audio.TrySetProviderId(MetadataProvider.MusicBrainzAlbum, mb);
 1340
 21341            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Release Group Id"))
 21342                 ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_RELEASEGROUPID"));
 21343            audio.TrySetProviderId(MetadataProvider.MusicBrainzReleaseGroup, mb);
 1344
 21345            mb = GetMultipleMusicBrainzId(tags.GetValueOrDefault("MusicBrainz Release Track Id"))
 21346                 ?? GetMultipleMusicBrainzId(tags.GetValueOrDefault("MUSICBRAINZ_RELEASETRACKID"));
 21347            audio.TrySetProviderId(MetadataProvider.MusicBrainzTrack, mb);
 21348        }
 1349
 1350        private string GetMultipleMusicBrainzId(string value)
 1351        {
 201352            if (string.IsNullOrWhiteSpace(value))
 1353            {
 101354                return null;
 1355            }
 1356
 101357            return value.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
 101358                .FirstOrDefault();
 1359        }
 1360
 1361        /// <summary>
 1362        /// Splits the specified val.
 1363        /// </summary>
 1364        /// <param name="val">The val.</param>
 1365        /// <param name="allowCommaDelimiter">if set to <c>true</c> [allow comma delimiter].</param>
 1366        /// <returns>System.String[][].</returns>
 1367        private string[] Split(string val, bool allowCommaDelimiter)
 1368        {
 1369            // Only use the comma as a delimiter if there are no slashes or pipes.
 1370            // We want to be careful not to split names that have commas in them
 141371            return !allowCommaDelimiter || _nameDelimiters.Any(i => val.Contains(i, StringComparison.Ordinal)) ?
 141372                val.Split(_nameDelimiters, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) :
 141373                val.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 1374        }
 1375
 1376        private IEnumerable<string> SplitDistinctArtists(string val, char[] delimiters, bool splitFeaturing)
 1377        {
 51378            if (splitFeaturing)
 1379            {
 31380                val = val.Replace(" featuring ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase)
 31381                    .Replace(" feat. ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase);
 1382            }
 1383
 51384            var artistsFound = new List<string>();
 1385
 3001386            foreach (var whitelistArtist in SplitWhitelist)
 1387            {
 1451388                var originalVal = val;
 1451389                val = val.Replace(whitelistArtist, "|", StringComparison.OrdinalIgnoreCase);
 1390
 1451391                if (!string.Equals(originalVal, val, StringComparison.OrdinalIgnoreCase))
 1392                {
 01393                    artistsFound.Add(whitelistArtist);
 1394                }
 1395            }
 1396
 51397            var artists = val.Split(delimiters, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 1398
 51399            artistsFound.AddRange(artists);
 51400            return artistsFound.DistinctNames();
 1401        }
 1402
 1403        /// <summary>
 1404        /// Gets the studios from the tags collection.
 1405        /// </summary>
 1406        /// <param name="info">The info.</param>
 1407        /// <param name="tags">The tags.</param>
 1408        /// <param name="tagName">Name of the tag.</param>
 1409        private void FetchStudios(MediaInfo info, IReadOnlyDictionary<string, string> tags, string tagName)
 1410        {
 161411            var val = tags.GetValueOrDefault(tagName);
 1412
 161413            if (string.IsNullOrEmpty(val))
 1414            {
 141415                return;
 1416            }
 1417
 21418            var studios = Split(val, true);
 21419            var studioList = new List<string>();
 1420
 81421            foreach (var studio in studios)
 1422            {
 21423                if (string.IsNullOrWhiteSpace(studio))
 1424                {
 1425                    continue;
 1426                }
 1427
 1428                // Don't add artist/album artist name to studios, even if it's listed there
 21429                if (info.Artists.Contains(studio, StringComparison.OrdinalIgnoreCase)
 21430                    || info.AlbumArtists.Contains(studio, StringComparison.OrdinalIgnoreCase))
 1431                {
 1432                    continue;
 1433                }
 1434
 21435                studioList.Add(studio);
 1436            }
 1437
 21438            info.Studios = studioList
 21439                .Distinct(StringComparer.OrdinalIgnoreCase)
 21440                .ToArray();
 21441        }
 1442
 1443        /// <summary>
 1444        /// Gets the genres from the tags collection.
 1445        /// </summary>
 1446        /// <param name="info">The information.</param>
 1447        /// <param name="tags">The tags.</param>
 1448        private void FetchGenres(MediaInfo info, IReadOnlyDictionary<string, string> tags)
 1449        {
 101450            var genreVal = tags.GetValueOrDefault("genre");
 101451            if (string.IsNullOrEmpty(genreVal))
 1452            {
 81453                return;
 1454            }
 1455
 21456            var genres = new List<string>(info.Genres);
 201457            foreach (var genre in Split(genreVal, true))
 1458            {
 81459                if (string.IsNullOrEmpty(genre))
 1460                {
 1461                    continue;
 1462                }
 1463
 81464                genres.Add(genre);
 1465            }
 1466
 21467            info.Genres = genres
 21468                .Distinct(StringComparer.OrdinalIgnoreCase)
 21469                .ToArray();
 21470        }
 1471
 1472        /// <summary>
 1473        /// Gets the track or disc number, which can be in the form of '1', or '1/3'.
 1474        /// </summary>
 1475        /// <param name="tags">The tags.</param>
 1476        /// <param name="tagName">Name of the tag.</param>
 1477        /// <returns>The track or disc number, or null, if missing or not parseable.</returns>
 1478        private static int? GetDictionaryTrackOrDiscNumber(IReadOnlyDictionary<string, string> tags, string tagName)
 1479        {
 41480            var disc = tags.GetValueOrDefault(tagName);
 1481
 41482            if (int.TryParse(disc.AsSpan().LeftPart('/'), out var discNum))
 1483            {
 41484                return discNum;
 1485            }
 1486
 01487            return null;
 1488        }
 1489
 1490        private static ChapterInfo GetChapterInfo(MediaChapter chapter)
 1491        {
 01492            var info = new ChapterInfo();
 1493
 01494            if (chapter.Tags is not null && chapter.Tags.TryGetValue("title", out string name))
 1495            {
 01496                info.Name = name;
 1497            }
 1498
 1499            // Limit accuracy to milliseconds to match xml saving
 01500            var secondsString = chapter.StartTime;
 1501
 01502            if (double.TryParse(secondsString, CultureInfo.InvariantCulture, out var seconds))
 1503            {
 01504                var ms = Math.Round(TimeSpan.FromSeconds(seconds).TotalMilliseconds);
 01505                info.StartPositionTicks = TimeSpan.FromMilliseconds(ms).Ticks;
 1506            }
 1507
 01508            return info;
 1509        }
 1510
 1511        private void FetchWtvInfo(MediaInfo video, InternalMediaInfoResult data)
 1512        {
 81513            var tags = data.Format?.Tags;
 1514
 81515            if (tags is null)
 1516            {
 31517                return;
 1518            }
 1519
 51520            if (tags.TryGetValue("WM/Genre", out var genres) && !string.IsNullOrWhiteSpace(genres))
 1521            {
 01522                var genreList = genres.Split(new[] { ';', '/', ',' }, StringSplitOptions.RemoveEmptyEntries | StringSpli
 1523
 1524                // If this is empty then don't overwrite genres that might have been fetched earlier
 01525                if (genreList.Length > 0)
 1526                {
 01527                    video.Genres = genreList;
 1528                }
 1529            }
 1530
 51531            if (tags.TryGetValue("WM/ParentalRating", out var officialRating) && !string.IsNullOrWhiteSpace(officialRati
 1532            {
 01533                video.OfficialRating = officialRating;
 1534            }
 1535
 51536            if (tags.TryGetValue("WM/MediaCredits", out var people) && !string.IsNullOrEmpty(people))
 1537            {
 01538                video.People = Array.ConvertAll(
 01539                    people.Split(new[] { ';', '/' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntr
 01540                    i => new BaseItemPerson { Name = i, Type = PersonKind.Actor });
 1541            }
 1542
 51543            if (tags.TryGetValue("WM/OriginalReleaseTime", out var year) && int.TryParse(year, NumberStyles.Integer, Cul
 1544            {
 01545                video.ProductionYear = parsedYear;
 1546            }
 1547
 1548            // Credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
 1549            // DateTime is reported along with timezone info (typically Z i.e. UTC hence assume None)
 51550            if (tags.TryGetValue("WM/MediaOriginalBroadcastDateTime", out var premiereDateString) && DateTime.TryParse(y
 1551            {
 01552                video.PremiereDate = parsedDate;
 1553            }
 1554
 51555            var description = tags.GetValueOrDefault("WM/SubTitleDescription");
 1556
 51557            var subTitle = tags.GetValueOrDefault("WM/SubTitle");
 1558
 1559            // For below code, credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
 1560
 1561            // Sometimes for TV Shows the Subtitle field is empty and the subtitle description contains the subtitle, ex
 1562            // The format is -> EPISODE/TOTAL_EPISODES_IN_SEASON. SUBTITLE: DESCRIPTION
 1563            // OR -> COMMENT. SUBTITLE: DESCRIPTION
 1564            // e.g. -> 4/13. The Doctor's Wife: Science fiction drama. When he follows a Time Lord distress signal, the 
 1565            // e.g. -> CBeebies Bedtime Hour. The Mystery: Animated adventures of two friends who live on an island in t
 51566            if (string.IsNullOrWhiteSpace(subTitle)
 51567                && !string.IsNullOrWhiteSpace(description)
 51568                && description.AsSpan()[..Math.Min(description.Length, MaxSubtitleDescriptionExtractionLength)].Contains
 1569            {
 01570                string[] descriptionParts = description.Split(':');
 01571                if (descriptionParts.Length > 0)
 1572                {
 01573                    string subtitle = descriptionParts[0];
 1574                    try
 1575                    {
 1576                        // Check if it contains a episode number and season number
 01577                        if (subtitle.Contains('/', StringComparison.Ordinal))
 1578                        {
 01579                            string[] subtitleParts = subtitle.Split(' ');
 01580                            string[] numbers = subtitleParts[0].Replace(".", string.Empty, StringComparison.Ordinal).Spl
 01581                            video.IndexNumber = int.Parse(numbers[0], CultureInfo.InvariantCulture);
 1582                            // int totalEpisodesInSeason = int.Parse(numbers[1], CultureInfo.InvariantCulture);
 1583
 1584                            // Skip the numbers, concatenate the rest, trim and set as new description
 01585                            description = string.Join(' ', subtitleParts, 1, subtitleParts.Length - 1).Trim();
 1586                        }
 01587                        else if (subtitle.Contains('.', StringComparison.Ordinal))
 1588                        {
 01589                            var subtitleParts = subtitle.Split('.');
 01590                            description = string.Join('.', subtitleParts, 1, subtitleParts.Length - 1).Trim();
 1591                        }
 1592                        else
 1593                        {
 01594                            description = subtitle.Trim();
 1595                        }
 01596                    }
 01597                    catch (Exception ex)
 1598                    {
 01599                        _logger.LogError(ex, "Error while parsing subtitle field");
 1600
 1601                        // Fallback to default parsing
 01602                        if (subtitle.Contains('.', StringComparison.Ordinal))
 1603                        {
 01604                            var subtitleParts = subtitle.Split('.');
 01605                            description = string.Join('.', subtitleParts, 1, subtitleParts.Length - 1).Trim();
 1606                        }
 1607                        else
 1608                        {
 01609                            description = subtitle.Trim();
 1610                        }
 01611                    }
 1612                }
 1613            }
 1614
 51615            if (!string.IsNullOrWhiteSpace(description))
 1616            {
 01617                video.Overview = description;
 1618            }
 51619        }
 1620
 1621        private void ExtractTimestamp(MediaInfo video)
 1622        {
 81623            if (video.VideoType != VideoType.VideoFile)
 1624            {
 01625                return;
 1626            }
 1627
 81628            if (!string.Equals(video.Container, "mpeg2ts", StringComparison.OrdinalIgnoreCase)
 81629                && !string.Equals(video.Container, "m2ts", StringComparison.OrdinalIgnoreCase)
 81630                && !string.Equals(video.Container, "ts", StringComparison.OrdinalIgnoreCase))
 1631            {
 71632                return;
 1633            }
 1634
 1635            try
 1636            {
 11637                video.Timestamp = GetMpegTimestamp(video.Path);
 01638                _logger.LogDebug("Video has {Timestamp} timestamp", video.Timestamp);
 01639            }
 11640            catch (Exception ex)
 1641            {
 11642                video.Timestamp = null;
 11643                _logger.LogError(ex, "Error extracting timestamp info from {Path}", video.Path);
 11644            }
 11645        }
 1646
 1647        // REVIEW: find out why the byte array needs to be 197 bytes long and comment the reason
 1648        private TransportStreamTimestamp GetMpegTimestamp(string path)
 1649        {
 11650            var packetBuffer = new byte[197];
 1651
 11652            using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1))
 1653            {
 01654                fs.ReadExactly(packetBuffer);
 01655            }
 1656
 01657            if (packetBuffer[0] == 71)
 1658            {
 01659                return TransportStreamTimestamp.None;
 1660            }
 1661
 01662            if ((packetBuffer[4] != 71) || (packetBuffer[196] != 71))
 1663            {
 01664                return TransportStreamTimestamp.None;
 1665            }
 1666
 01667            if ((packetBuffer[0] == 0) && (packetBuffer[1] == 0) && (packetBuffer[2] == 0) && (packetBuffer[3] == 0))
 1668            {
 01669                return TransportStreamTimestamp.Zero;
 1670            }
 1671
 01672            return TransportStreamTimestamp.Valid;
 1673        }
 1674
 1675        [GeneratedRegex("(?<name>.*) \\((?<instrument>.*)\\)")]
 1676        private static partial Regex PerformerRegex();
 1677    }
 1678}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:22 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.Extensions.Logging.ILogger,MediaBrowser.Model.Globalization.ILocalizationManager)
get_SplitWhitelist()
GetMediaInfo(MediaBrowser.MediaEncoding.Probing.InternalMediaInfoResult,System.Nullable`1<MediaBrowser.Model.Entities.VideoType>,System.Boolean,System.String,MediaBrowser.Model.MediaInfo.MediaProtocol)
NormalizeFormat(System.String,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Model.Entities.MediaStream>)
GetEstimatedAudioBitrate(System.String,System.Nullable`1<System.Int32>)
FetchFromItunesInfo(System.String,MediaBrowser.Model.MediaInfo.MediaInfo)
ReadFromDictNode(System.Xml.XmlReader,MediaBrowser.Model.MediaInfo.MediaInfo)
ReadValueArray(System.Xml.XmlReader)
ProcessPairs(System.String,System.Collections.Generic.List`1<MediaBrowser.Model.Dto.NameValuePair>,MediaBrowser.Model.MediaInfo.MediaInfo)
GetNameValuePair(System.Xml.XmlReader)
NormalizeSubtitleCodec(System.String)
GetMediaAttachment(MediaBrowser.MediaEncoding.Probing.MediaStreamInfo)
GetMediaStream(System.Boolean,MediaBrowser.MediaEncoding.Probing.MediaStreamInfo,MediaBrowser.MediaEncoding.Probing.MediaFormatInfo)
NormalizeStreamTitle(MediaBrowser.Model.Entities.MediaStream)
GetDictionaryValue(System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String)
ParseChannelLayout(System.String)
GetAspectRatio(MediaBrowser.MediaEncoding.Probing.MediaStreamInfo)
IsClose(System.Double,System.Double,System.Double)
GetFrameRate(System.ReadOnlySpan`1<System.Char>)
SetAudioRuntimeTicks(MediaBrowser.MediaEncoding.Probing.InternalMediaInfoResult,MediaBrowser.Model.MediaInfo.MediaInfo)
GetBPSFromTags(MediaBrowser.MediaEncoding.Probing.MediaStreamInfo)
GetRuntimeSecondsFromTags(MediaBrowser.MediaEncoding.Probing.MediaStreamInfo)
GetNumberOfBytesFromTags(MediaBrowser.MediaEncoding.Probing.MediaStreamInfo)
SetSize(MediaBrowser.MediaEncoding.Probing.InternalMediaInfoResult,MediaBrowser.Model.MediaInfo.MediaInfo)
SetAudioInfoFromTags(MediaBrowser.Model.MediaInfo.MediaInfo,System.Collections.Generic.Dictionary`2<System.String,System.String>)
GetMultipleMusicBrainzId(System.String)
Split(System.String,System.Boolean)
SplitDistinctArtists(System.String,System.Char[],System.Boolean)
FetchStudios(MediaBrowser.Model.MediaInfo.MediaInfo,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String)
FetchGenres(MediaBrowser.Model.MediaInfo.MediaInfo,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>)
GetDictionaryTrackOrDiscNumber(System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String)
GetChapterInfo(MediaBrowser.MediaEncoding.Probing.MediaChapter)
FetchWtvInfo(MediaBrowser.Model.MediaInfo.MediaInfo,MediaBrowser.MediaEncoding.Probing.InternalMediaInfoResult)
ExtractTimestamp(MediaBrowser.Model.MediaInfo.MediaInfo)
GetMpegTimestamp(System.String)