From 61178832c1e2b95fe5df015c034b383e40eb5035 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Mon, 31 Oct 2022 01:00:39 -0500
Subject: [PATCH 01/22] Add initial end credits detection code

---
 CHANGELOG.md                                  |   2 +
 .../TestAudioFingerprinting.cs                |  10 +-
 .../Analyzers/Chromaprint.cs                  |  54 +++--
 .../Configuration/PluginConfiguration.cs      |   5 +
 .../Controllers/VisualizationController.cs    |   2 +-
 .../Data/QueuedEpisode.cs                     |  14 +-
 .../FFmpegWrapper.cs                          |  90 ++++++--
 .../Plugin.cs                                 |  63 +++++-
 .../QueueManager.cs                           |  15 +-
 .../ScheduledTasks/AnalyzeEpisodesTask.cs     |   2 +
 .../ScheduledTasks/DetectCreditsTask.cs       | 197 ++++++++++++++++++
 README.md                                     |   6 +-
 12 files changed, 409 insertions(+), 51 deletions(-)
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7727813..cd38246 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,8 @@
 # Changelog
 
 ## v0.1.8.0 (no eta)
+* New features
+  * Detect ending credits in television episodes
 * Internal changes
   * Move Chromaprint analysis code out of the episode analysis task
   * Add support for multiple analysis techinques
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestAudioFingerprinting.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestAudioFingerprinting.cs
index 5470b4f..e758469 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestAudioFingerprinting.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestAudioFingerprinting.cs
@@ -59,7 +59,9 @@ public void TestFingerprinting()
             3472417825, 3395841056, 3458735136, 3341420624, 1076496560, 1076501168, 1076501136, 1076497024
         };
 
-        var actual = FFmpegWrapper.Fingerprint(queueEpisode("audio/big_buck_bunny_intro.mp3"));
+        var actual = FFmpegWrapper.Fingerprint(
+            queueEpisode("audio/big_buck_bunny_intro.mp3"),
+            AnalysisMode.Introduction);
 
         Assert.Equal(expected, actual);
     }
@@ -91,8 +93,8 @@ public void TestIntroDetection()
 
         var lhsEpisode = queueEpisode("audio/big_buck_bunny_intro.mp3");
         var rhsEpisode = queueEpisode("audio/big_buck_bunny_clip.mp3");
-        var lhsFingerprint = FFmpegWrapper.Fingerprint(lhsEpisode);
-        var rhsFingerprint = FFmpegWrapper.Fingerprint(rhsEpisode);
+        var lhsFingerprint = FFmpegWrapper.Fingerprint(lhsEpisode, AnalysisMode.Introduction);
+        var rhsFingerprint = FFmpegWrapper.Fingerprint(rhsEpisode, AnalysisMode.Introduction);
 
         var (lhs, rhs) = chromaprint.CompareEpisodes(
             lhsEpisode.EpisodeId,
@@ -138,7 +140,7 @@ private QueuedEpisode queueEpisode(string path)
         {
             EpisodeId = Guid.NewGuid(),
             Path = "../../../" + path,
-            FingerprintDuration = 60
+            IntroFingerprintEnd = 60
         };
     }
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs
index 319d678..04f9da0 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs
@@ -30,6 +30,8 @@ public class ChromaprintAnalyzer : IMediaFileAnalyzer
 
     private ILogger<ChromaprintAnalyzer> _logger;
 
+    private AnalysisMode _analysisMode;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ChromaprintAnalyzer"/> class.
     /// </summary>
@@ -64,12 +66,14 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         // Episodes that were analyzed and do not have an introduction.
         var episodesWithoutIntros = new List<QueuedEpisode>();
 
+        this._analysisMode = mode;
+
         // Compute fingerprints for all episodes in the season
         foreach (var episode in episodeAnalysisQueue)
         {
             try
             {
-                fingerprintCache[episode.EpisodeId] = FFmpegWrapper.Fingerprint(episode);
+                fingerprintCache[episode.EpisodeId] = FFmpegWrapper.Fingerprint(episode, mode);
 
                 if (cancellationToken.IsCancellationRequested)
                 {
@@ -78,6 +82,7 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
             }
             catch (FingerprintException ex)
             {
+                // TODO: FIXME: move to debug level?
                 _logger.LogWarning("Caught fingerprint error: {Ex}", ex);
 
                 // Fallback to an empty fingerprint on any error
@@ -112,6 +117,22 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
                     continue;
                 }
 
+                /* Since the Fingerprint() function returns an array of Chromaprint points without time
+                 * information, the times reported from the index search function start from 0.
+                 *
+                 * While this is desired behavior for detecting introductions, it breaks credit
+                 * detection, as the audio we're analyzing was extracted from some point into the file.
+                 *
+                 * To fix this, add the starting time of the fingerprint to the reported time range.
+                 */
+                if (this._analysisMode == AnalysisMode.Credits)
+                {
+                    currentIntro.IntroStart += currentEpisode.CreditsFingerprintStart;
+                    currentIntro.IntroEnd += currentEpisode.CreditsFingerprintStart;
+                    remainingIntro.IntroStart += remainingEpisode.CreditsFingerprintStart;
+                    remainingIntro.IntroEnd += remainingEpisode.CreditsFingerprintStart;
+                }
+
                 // Only save the discovered intro if it is:
                 // - the first intro discovered for this episode
                 // - longer than the previously discovered intro
@@ -142,10 +163,13 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
             return analysisQueue;
         }
 
-        // Adjust all introduction end times so that they end at silence.
-        seasonIntros = AdjustIntroEndTimes(analysisQueue, seasonIntros);
+        if (this._analysisMode == AnalysisMode.Introduction)
+        {
+            // Adjust all introduction end times so that they end at silence.
+            seasonIntros = AdjustIntroEndTimes(analysisQueue, seasonIntros);
+        }
 
-        Plugin.Instance!.UpdateTimestamps(seasonIntros);
+        Plugin.Instance!.UpdateTimestamps(seasonIntros, this._analysisMode);
 
         return episodesWithoutIntros.AsReadOnly();
     }
@@ -338,16 +362,20 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         // Since LHS had a contiguous time range, RHS must have one also.
         var rContiguous = TimeRangeHelpers.FindContiguous(rhsTimes.ToArray(), maximumTimeSkip)!;
 
-        // Tweak the end timestamps just a bit to ensure as little content as possible is skipped over.
-        if (lContiguous.Duration >= 90)
+        if (this._analysisMode == AnalysisMode.Introduction)
         {
-            lContiguous.End -= 2 * maximumTimeSkip;
-            rContiguous.End -= 2 * maximumTimeSkip;
-        }
-        else if (lContiguous.Duration >= 30)
-        {
-            lContiguous.End -= maximumTimeSkip;
-            rContiguous.End -= maximumTimeSkip;
+            // Tweak the end timestamps just a bit to ensure as little content as possible is skipped over.
+            // TODO: remove this
+            if (lContiguous.Duration >= 90)
+            {
+                lContiguous.End -= 2 * maximumTimeSkip;
+                rContiguous.End -= 2 * maximumTimeSkip;
+            }
+            else if (lContiguous.Duration >= 30)
+            {
+                lContiguous.End -= maximumTimeSkip;
+                rContiguous.End -= maximumTimeSkip;
+            }
         }
 
         return (lContiguous, rContiguous);
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
index e382bf2..ce79fdd 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
@@ -72,6 +72,11 @@ public PluginConfiguration()
     /// </summary>
     public int MaximumIntroDuration { get; set; } = 120;
 
+    /// <summary>
+    /// Gets or sets the upper limit (in minutes) on the length of each episode's audio track that will be analyzed when searching for ending credits.
+    /// </summary>
+    public int MaximumEpisodeCreditsDuration { get; set; } = 4;
+
     // ===== Playback settings =====
 
     /// <summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
index d4cec0d..f2331ab 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
@@ -113,7 +113,7 @@ public ActionResult<uint[]> GetEpisodeFingerprint([FromRoute] Guid id)
             {
                 if (needle.EpisodeId == id)
                 {
-                    return FFmpegWrapper.Fingerprint(needle);
+                    return FFmpegWrapper.Fingerprint(needle, AnalysisMode.Introduction);
                 }
             }
         }
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
index 915d33f..0964258 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
@@ -33,7 +33,17 @@ public class QueuedEpisode
     public string Name { get; set; } = string.Empty;
 
     /// <summary>
-    /// Gets or sets the seconds of media file to fingerprint.
+    /// Gets or sets the timestamp (in seconds) to stop searching for an introduction.
     /// </summary>
-    public int FingerprintDuration { get; set; }
+    public int IntroFingerprintEnd { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp (in seconds) to start looking for end credits.
+    /// </summary>
+    public int CreditsFingerprintStart { get; set; }
+
+    /// <summary>
+    /// Gets or sets the total duration of this media file (in seconds).
+    /// </summary>
+    public int Duration { get; set; }
 }
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
index 86dad74..fdae152 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
@@ -134,27 +134,60 @@ private static bool CheckFFmpegRequirement(
     /// Fingerprint a queued episode.
     /// </summary>
     /// <param name="episode">Queued episode to fingerprint.</param>
+    /// <param name="mode">Portion of media file to fingerprint. Introduction = first 25% / 10 minutes and Credits = last 4 minutes.</param>
     /// <returns>Numerical fingerprint points.</returns>
-    public static uint[] Fingerprint(QueuedEpisode episode)
+    public static uint[] Fingerprint(QueuedEpisode episode, AnalysisMode mode)
+    {
+        int start, end;
+
+        if (mode == AnalysisMode.Introduction)
+        {
+            start = 0;
+            end = episode.IntroFingerprintEnd;
+        }
+        else if (mode == AnalysisMode.Credits)
+        {
+            start = episode.CreditsFingerprintStart;
+            end = episode.Duration;
+        }
+        else
+        {
+            throw new ArgumentException("Unknown analysis mode " + mode.ToString());
+        }
+
+        return Fingerprint(episode, mode, start, end);
+    }
+
+    /// <summary>
+    /// Fingerprint a queued episode.
+    /// </summary>
+    /// <param name="episode">Queued episode to fingerprint.</param>
+    /// <param name="mode">Portion of media file to fingerprint.</param>
+    /// <param name="start">Time (in seconds) relative to the start of the file to start fingerprinting from.</param>
+    /// <param name="end">Time (in seconds) relative to the start of the file to stop fingerprinting at.</param>
+    /// <returns>Numerical fingerprint points.</returns>
+    private static uint[] Fingerprint(QueuedEpisode episode, AnalysisMode mode, int start, int end)
     {
         // Try to load this episode from cache before running ffmpeg.
-        if (LoadCachedFingerprint(episode, out uint[] cachedFingerprint))
+        if (LoadCachedFingerprint(episode, mode, out uint[] cachedFingerprint))
         {
             Logger?.LogTrace("Fingerprint cache hit on {File}", episode.Path);
             return cachedFingerprint;
         }
 
         Logger?.LogDebug(
-            "Fingerprinting {Duration} seconds from \"{File}\" (id {Id})",
-            episode.FingerprintDuration,
+            "Fingerprinting [{Start}, {End}] from \"{File}\" (id {Id})",
+            start,
+            end,
             episode.Path,
             episode.EpisodeId);
 
         var args = string.Format(
             CultureInfo.InvariantCulture,
-            "-i \"{0}\" -to {1} -ac 2 -f chromaprint -fp_format raw -",
+            "-ss {0} -i \"{1}\" -to {2} -ac 2 -f chromaprint -fp_format raw -",
+            start,
             episode.Path,
-            episode.FingerprintDuration);
+            end - start);
 
         // Returns all fingerprint points as raw 32 bit unsigned integers (little endian).
         var rawPoints = GetOutput(args, string.Empty);
@@ -172,7 +205,7 @@ public static uint[] Fingerprint(QueuedEpisode episode)
         }
 
         // Try to cache this fingerprint.
-        CacheFingerprint(episode, results);
+        CacheFingerprint(episode, mode, results);
 
         return results.ToArray();
     }
@@ -226,9 +259,6 @@ public static TimeRange[] DetectSilence(QueuedEpisode episode, int limit)
             limit,
             episode.EpisodeId);
 
-        // TODO: select the audio track that matches the user's preferred language, falling
-        //     back to the first track if nothing matches
-
         // -vn, -sn, -dn: ignore video, subtitle, and data tracks
         var args = string.Format(
             CultureInfo.InvariantCulture,
@@ -367,9 +397,13 @@ private static ReadOnlySpan<byte> GetOutput(
     /// This function was created before the unified caching mechanism was introduced (in v0.1.7).
     /// </summary>
     /// <param name="episode">Episode to try to load from cache.</param>
+    /// <param name="mode">Analysis mode.</param>
     /// <param name="fingerprint">Array to store the fingerprint in.</param>
     /// <returns>true if the episode was successfully loaded from cache, false on any other error.</returns>
-    private static bool LoadCachedFingerprint(QueuedEpisode episode, out uint[] fingerprint)
+    private static bool LoadCachedFingerprint(
+        QueuedEpisode episode,
+        AnalysisMode mode,
+        out uint[] fingerprint)
     {
         fingerprint = Array.Empty<uint>();
 
@@ -379,7 +413,7 @@ private static bool LoadCachedFingerprint(QueuedEpisode episode, out uint[] fing
             return false;
         }
 
-        var path = GetFingerprintCachePath(episode);
+        var path = GetFingerprintCachePath(episode, mode);
 
         // If this episode isn't cached, bail out.
         if (!File.Exists(path))
@@ -387,7 +421,6 @@ private static bool LoadCachedFingerprint(QueuedEpisode episode, out uint[] fing
             return false;
         }
 
-        // TODO: make async
         var raw = File.ReadAllLines(path, Encoding.UTF8);
         var result = new List<uint>();
 
@@ -421,8 +454,12 @@ private static bool LoadCachedFingerprint(QueuedEpisode episode, out uint[] fing
     /// This function was created before the unified caching mechanism was introduced (in v0.1.7).
     /// </summary>
     /// <param name="episode">Episode to store in cache.</param>
+    /// <param name="mode">Analysis mode.</param>
     /// <param name="fingerprint">Fingerprint of the episode to store.</param>
-    private static void CacheFingerprint(QueuedEpisode episode, List<uint> fingerprint)
+    private static void CacheFingerprint(
+        QueuedEpisode episode,
+        AnalysisMode mode,
+        List<uint> fingerprint)
     {
         // Bail out if caching isn't enabled.
         if (!(Plugin.Instance?.Configuration.CacheFingerprints ?? false))
@@ -438,7 +475,10 @@ private static void CacheFingerprint(QueuedEpisode episode, List<uint> fingerpri
         }
 
         // Cache the episode.
-        File.WriteAllLinesAsync(GetFingerprintCachePath(episode), lines, Encoding.UTF8).ConfigureAwait(false);
+        File.WriteAllLinesAsync(
+            GetFingerprintCachePath(episode, mode),
+            lines,
+            Encoding.UTF8).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -446,9 +486,25 @@ private static void CacheFingerprint(QueuedEpisode episode, List<uint> fingerpri
     /// This function was created before the unified caching mechanism was introduced (in v0.1.7).
     /// </summary>
     /// <param name="episode">Episode.</param>
-    private static string GetFingerprintCachePath(QueuedEpisode episode)
+    /// <param name="mode">Analysis mode.</param>
+    private static string GetFingerprintCachePath(QueuedEpisode episode, AnalysisMode mode)
     {
-        return Path.Join(Plugin.Instance!.FingerprintCachePath, episode.EpisodeId.ToString("N"));
+        var basePath = Path.Join(
+            Plugin.Instance!.FingerprintCachePath,
+            episode.EpisodeId.ToString("N"));
+
+        if (mode == AnalysisMode.Introduction)
+        {
+            return basePath;
+        }
+        else if (mode == AnalysisMode.Credits)
+        {
+            return basePath + "-credits";
+        }
+        else
+        {
+            throw new ArgumentException("Unknown analysis mode " + mode.ToString());
+        }
     }
 
     /// <summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
index 94604d9..bf5d241 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
@@ -6,6 +6,7 @@
 using MediaBrowser.Common.Plugins;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Plugins;
 using MediaBrowser.Model.Serialization;
@@ -24,6 +25,7 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     private ILibraryManager _libraryManager;
     private ILogger<Plugin> _logger;
     private string _introPath;
+    private string _creditsPath;  // TODO: FIXME: remove this
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Plugin"/> class.
@@ -51,6 +53,9 @@ public Plugin(
         FFmpegPath = serverConfiguration.GetEncodingOptions().EncoderAppPathDisplay;
         _introPath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "intros.xml");
 
+        // TODO: FIXME: remove this
+        _creditsPath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "credits.csv");
+
         // Create the base & cache directories (if needed).
         if (!Directory.Exists(FingerprintCachePath))
         {
@@ -68,6 +73,12 @@ public Plugin(
         {
             _logger.LogWarning("Unable to load introduction timestamps: {Exception}", ex);
         }
+
+        // TODO: FIXME: remove this
+        if (File.Exists(_creditsPath))
+        {
+            File.Delete(_creditsPath);
+        }
     }
 
     /// <summary>
@@ -163,16 +174,52 @@ internal string GetItemPath(Guid id)
         return GetItem(id).Path;
     }
 
-    internal void UpdateTimestamps(Dictionary<Guid, Intro> newIntros)
+    internal void UpdateTimestamps(Dictionary<Guid, Intro> newIntros, AnalysisMode mode)
     {
-        lock (_introsLock)
+        switch (mode)
         {
-            foreach (var intro in newIntros)
-            {
-                Plugin.Instance!.Intros[intro.Key] = intro.Value;
-            }
-
-            Plugin.Instance!.SaveTimestamps();
+            case AnalysisMode.Introduction:
+                lock (_introsLock)
+                {
+                    foreach (var intro in newIntros)
+                    {
+                        Plugin.Instance!.Intros[intro.Key] = intro.Value;
+                    }
+
+                    Plugin.Instance!.SaveTimestamps();
+                }
+
+                break;
+
+            case AnalysisMode.Credits:
+                // TODO: FIXME: implement properly
+
+                lock (_introsLock)
+                {
+                    foreach (var credit in newIntros)
+                    {
+                        var item = GetItem(credit.Value.EpisodeId) as Episode;
+                        if (item is null)
+                        {
+                            continue;
+                        }
+
+                        // Format: series, season number, episode number, title, start, end
+                        var contents = string.Format(
+                            System.Globalization.CultureInfo.InvariantCulture,
+                            "{0},{1},{2},{3},{4},{5}\n",
+                            item.SeriesName.Replace(",", string.Empty, StringComparison.Ordinal),
+                            item.AiredSeasonNumber ?? 0,
+                            item.IndexNumber ?? 0,
+                            item.Name.Replace(",", string.Empty, StringComparison.Ordinal),
+                            Math.Round(credit.Value.IntroStart, 2),
+                            Math.Round(credit.Value.IntroEnd, 2));
+
+                        File.AppendAllText(_creditsPath, contents);
+                    }
+                }
+
+                break;
         }
     }
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
index 3395243..be905e6 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
@@ -186,17 +186,22 @@ private void QueueEpisode(Episode episode)
         // Limit analysis to the first X% of the episode and at most Y minutes.
         // X and Y default to 25% and 10 minutes.
         var duration = TimeSpan.FromTicks(episode.RunTimeTicks ?? 0).TotalSeconds;
-        if (duration >= 5 * 60)
+        var fingerprintDuration = duration;
+
+        if (fingerprintDuration >= 5 * 60)
         {
-            duration *= analysisPercent;
+            fingerprintDuration *= analysisPercent;
         }
 
-        duration = Math.Min(duration, 60 * Plugin.Instance!.Configuration.AnalysisLengthLimit);
+        fingerprintDuration = Math.Min(
+            fingerprintDuration,
+            60 * Plugin.Instance!.Configuration.AnalysisLengthLimit);
 
         // Allocate a new list for each new season
         Plugin.Instance!.AnalysisQueue.TryAdd(episode.SeasonId, new List<QueuedEpisode>());
 
         // Queue the episode for analysis
+        var maxCreditsDuration = Plugin.Instance!.Configuration.MaximumEpisodeCreditsDuration * 60;
         Plugin.Instance.AnalysisQueue[episode.SeasonId].Add(new QueuedEpisode()
         {
             SeriesName = episode.SeriesName,
@@ -204,7 +209,9 @@ private void QueueEpisode(Episode episode)
             EpisodeId = episode.Id,
             Name = episode.Name,
             Path = episode.Path,
-            FingerprintDuration = Convert.ToInt32(duration)
+            Duration = Convert.ToInt32(duration),
+            IntroFingerprintEnd = Convert.ToInt32(fingerprintDuration),
+            CreditsFingerprintStart = Convert.ToInt32(duration - maxCreditsDuration),
         });
 
         Plugin.Instance!.TotalQueued++;
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs
index 3b1c531..6d563fc 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs
@@ -12,6 +12,7 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 
 /// <summary>
 /// Analyze all television episodes for introduction sequences.
+/// TODO: FIXME: rename task and file to DetectIntroductionsTask.
 /// </summary>
 public class AnalyzeEpisodesTask : IScheduledTask
 {
@@ -178,6 +179,7 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
 
     /// <summary>
     /// Verify that all episodes in a season exist in Jellyfin and as a file in storage.
+    /// TODO: FIXME: move to queue manager.
     /// </summary>
     /// <param name="candidates">QueuedEpisodes.</param>
     /// <returns>Verified QueuedEpisodes and a flag indicating if any episode in this season has not been analyzed yet.</returns>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
new file mode 100644
index 0000000..224155f
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace ConfusedPolarBear.Plugin.IntroSkipper;
+
+#if !DEBUG
+#error Fix all FIXMEs introduced during initial credit implementation before release
+#endif
+
+/// <summary>
+/// Analyze all television episodes for credits.
+/// </summary>
+public class DetectCreditsTask : IScheduledTask
+{
+    private readonly ILogger<DetectCreditsTask> _logger;
+
+    private readonly ILoggerFactory _loggerFactory;
+
+    private readonly ILibraryManager? _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DetectCreditsTask"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">Logger factory.</param>
+    /// <param name="libraryManager">Library manager.</param>
+    public DetectCreditsTask(
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager) : this(loggerFactory)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DetectCreditsTask"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">Logger factory.</param>
+    public DetectCreditsTask(ILoggerFactory loggerFactory)
+    {
+        _logger = loggerFactory.CreateLogger<DetectCreditsTask>();
+        _loggerFactory = loggerFactory;
+    }
+
+    /// <summary>
+    /// Gets the task name.
+    /// </summary>
+    public string Name => "Detect Credits";
+
+    /// <summary>
+    /// Gets the task category.
+    /// </summary>
+    public string Category => "Intro Skipper";
+
+    /// <summary>
+    /// Gets the task description.
+    /// </summary>
+    public string Description => "Analyzes the audio and video of all television episodes to find credits.";
+
+    /// <summary>
+    /// Gets the task key.
+    /// </summary>
+    public string Key => "CPBIntroSkipperDetectCredits";
+
+    /// <summary>
+    /// Analyze all episodes in the queue. Only one instance of this task should be run at a time.
+    /// </summary>
+    /// <param name="progress">Task progress.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Task.</returns>
+    public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        if (_libraryManager is null)
+        {
+            throw new InvalidOperationException("Library manager must not be null");
+        }
+
+        // Make sure the analysis queue matches what's currently in Jellyfin.
+        var queueManager = new QueueManager(
+            _loggerFactory.CreateLogger<QueueManager>(),
+            _libraryManager);
+
+        queueManager.EnqueueAllEpisodes();
+
+        var queue = Plugin.Instance!.AnalysisQueue;
+
+        if (queue.Count == 0)
+        {
+            throw new FingerprintException(
+                "No episodes to analyze. If you are limiting the list of libraries to analyze, check that all library names have been spelled correctly.");
+        }
+
+        var totalProcessed = 0;
+        var options = new ParallelOptions()
+        {
+            MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
+        };
+
+        // TODO: FIXME: if the queue is modified while the task is running, the task will fail.
+        // clone the queue before running the task to prevent this.
+
+        // Analyze all episodes in the queue using the degrees of parallelism the user specified.
+        Parallel.ForEach(queue, options, (season) =>
+        {
+            // TODO: FIXME: use VerifyEpisodes
+            var episodes = season.Value.AsReadOnly();
+            if (episodes.Count == 0)
+            {
+                return;
+            }
+
+            var first = episodes[0];
+
+            try
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                // Increment totalProcessed by the number of episodes in this season that were actually analyzed
+                // (instead of just using the number of episodes in the current season).
+                var analyzed = AnalyzeSeason(episodes, cancellationToken);
+                Interlocked.Add(ref totalProcessed, analyzed);
+            }
+            catch (FingerprintException ex)
+            {
+                _logger.LogWarning(
+                    "Unable to analyze {Series} season {Season}: unable to fingerprint: {Ex}",
+                    first.SeriesName,
+                    first.SeasonNumber,
+                    ex);
+            }
+            catch (KeyNotFoundException ex)
+            {
+                _logger.LogWarning(
+                    "Unable to analyze {Series} season {Season}: cache miss: {Ex}",
+                    first.SeriesName,
+                    first.SeasonNumber,
+                    ex);
+            }
+
+            progress.Report((totalProcessed * 100) / Plugin.Instance!.TotalQueued);
+        });
+
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Fingerprints all episodes in the provided season and stores the timestamps of all introductions.
+    /// </summary>
+    /// <param name="episodes">Episodes in this season.</param>
+    /// <param name="cancellationToken">Cancellation token provided by the scheduled task.</param>
+    /// <returns>Number of episodes from the provided season that were analyzed.</returns>
+    private int AnalyzeSeason(
+        ReadOnlyCollection<QueuedEpisode> episodes,
+        CancellationToken cancellationToken)
+    {
+        // Skip seasons with an insufficient number of episodes.
+        if (episodes.Count <= 1)
+        {
+            return episodes.Count;
+        }
+
+        // Only analyze specials (season 0) if the user has opted in.
+        var first = episodes[0];
+        if (first.SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
+        {
+            return 0;
+        }
+
+        _logger.LogInformation(
+            "Analyzing {Count} episodes from {Name} season {Season}",
+            episodes.Count,
+            first.SeriesName,
+            first.SeasonNumber);
+
+        // Analyze the season with Chromaprint
+        var chromaprint = new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>());
+        chromaprint.AnalyzeMediaFiles(episodes, AnalysisMode.Credits, cancellationToken);
+
+        return episodes.Count;
+    }
+
+    /// <summary>
+    /// Get task triggers.
+    /// </summary>
+    /// <returns>Task triggers.</returns>
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        return Array.Empty<TaskTriggerInfo>();
+    }
+}
diff --git a/README.md b/README.md
index 8d3589d..e3ac776 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 <img alt="Plugin Banner" src="https://raw.githubusercontent.com/ConfusedPolarBear/intro-skipper/master/images/logo.png" />
 </div>
 
-Analyzes the audio of television episodes to detect and skip over intros.
+Analyzes the audio of television episodes to detect and skip over introductions and ending credits.
 
 If you use the custom web interface on your server, you will be able to click a button to skip intros, like this:
 
@@ -20,13 +20,15 @@ However, if you want to use an unmodified installation of Jellyfin 10.8.z or use
   * `linuxserver/jellyfin` 10.8.z container: preinstalled
   * Debian Linux based native installs: provided by the `jellyfin-ffmpeg5` package
 
-## Introduction requirements
+## Introduction and end credit requirements
 
 Show introductions will only be detected if they are:
 
 * Located within the first 25% of an episode, or the first 10 minutes, whichever is smaller
 * Between 15 seconds and 2 minutes long
 
+Ending credits will only be detected if they are shorter than 4 minutes.
+
 All of these requirements can be customized as needed.
 
 ## Installation instructions

From ff9ba16300829747f5a853e4ac965da99e5fcf6e Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Mon, 31 Oct 2022 01:16:55 -0500
Subject: [PATCH 02/22] Update e2e test code

---
 .../e2e_tests/verifier/report_generator.go                   | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
index 4814022..708f864 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"os/exec"
 	"strings"
 	"time"
 
@@ -77,7 +78,6 @@ func generateReport(hostAddress, apiKey, reportDestination string, keepTimestamp
 	fmt.Println()
 	fmt.Println("[+] Saving report")
 
-	// TODO: also save analysis statistics
 	// Store timing data, server information, and plugin configuration
 	report.StartedAt = start
 	report.FinishedAt = time.Now()
@@ -95,6 +95,9 @@ func generateReport(hostAddress, apiKey, reportDestination string, keepTimestamp
 		panic(err)
 	}
 
+	// Change report permissions
+	exec.Command("chown", "1000:1000", reportDestination).Run()
+
 	fmt.Println("[+] Done")
 }
 

From af89e5f2b426b7cbf36c0826e0705de74712d0fb Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Mon, 31 Oct 2022 01:47:41 -0500
Subject: [PATCH 03/22] Reorganize FFmpeg wrapper

---
 .../FFmpegWrapper.cs                          | 242 +++++++++---------
 1 file changed, 121 insertions(+), 121 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
index fdae152..66fc68b 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
@@ -98,38 +98,6 @@ public static bool CheckFFmpegVersion()
         }
     }
 
-    /// <summary>
-    /// Run an FFmpeg command with the provided arguments and validate that the output contains
-    /// the provided string.
-    /// </summary>
-    /// <param name="arguments">Arguments to pass to FFmpeg.</param>
-    /// <param name="mustContain">String that the output must contain. Case insensitive.</param>
-    /// <param name="bundleName">Support bundle key to store FFmpeg's output under.</param>
-    /// <param name="errorMessage">Error message to log if this requirement is not met.</param>
-    /// <returns>true on success, false on error.</returns>
-    private static bool CheckFFmpegRequirement(
-        string arguments,
-        string mustContain,
-        string bundleName,
-        string errorMessage)
-    {
-        Logger?.LogDebug("Checking FFmpeg requirement {Arguments}", arguments);
-
-        var output = Encoding.UTF8.GetString(GetOutput(arguments, string.Empty, false, 2000));
-        Logger?.LogTrace("Output of ffmpeg {Arguments}: {Output}", arguments, output);
-        ChromaprintLogs[bundleName] = output;
-
-        if (!output.Contains(mustContain, StringComparison.OrdinalIgnoreCase))
-        {
-            Logger?.LogError("{ErrorMessage}", errorMessage);
-            return false;
-        }
-
-        Logger?.LogDebug("FFmpeg requirement {Arguments} met", arguments);
-
-        return true;
-    }
-
     /// <summary>
     /// Fingerprint a queued episode.
     /// </summary>
@@ -158,58 +126,6 @@ public static uint[] Fingerprint(QueuedEpisode episode, AnalysisMode mode)
         return Fingerprint(episode, mode, start, end);
     }
 
-    /// <summary>
-    /// Fingerprint a queued episode.
-    /// </summary>
-    /// <param name="episode">Queued episode to fingerprint.</param>
-    /// <param name="mode">Portion of media file to fingerprint.</param>
-    /// <param name="start">Time (in seconds) relative to the start of the file to start fingerprinting from.</param>
-    /// <param name="end">Time (in seconds) relative to the start of the file to stop fingerprinting at.</param>
-    /// <returns>Numerical fingerprint points.</returns>
-    private static uint[] Fingerprint(QueuedEpisode episode, AnalysisMode mode, int start, int end)
-    {
-        // Try to load this episode from cache before running ffmpeg.
-        if (LoadCachedFingerprint(episode, mode, out uint[] cachedFingerprint))
-        {
-            Logger?.LogTrace("Fingerprint cache hit on {File}", episode.Path);
-            return cachedFingerprint;
-        }
-
-        Logger?.LogDebug(
-            "Fingerprinting [{Start}, {End}] from \"{File}\" (id {Id})",
-            start,
-            end,
-            episode.Path,
-            episode.EpisodeId);
-
-        var args = string.Format(
-            CultureInfo.InvariantCulture,
-            "-ss {0} -i \"{1}\" -to {2} -ac 2 -f chromaprint -fp_format raw -",
-            start,
-            episode.Path,
-            end - start);
-
-        // Returns all fingerprint points as raw 32 bit unsigned integers (little endian).
-        var rawPoints = GetOutput(args, string.Empty);
-        if (rawPoints.Length == 0 || rawPoints.Length % 4 != 0)
-        {
-            Logger?.LogWarning("Chromaprint returned {Count} points for \"{Path}\"", rawPoints.Length, episode.Path);
-            throw new FingerprintException("chromaprint output for \"" + episode.Path + "\" was malformed");
-        }
-
-        var results = new List<uint>();
-        for (var i = 0; i < rawPoints.Length; i += 4)
-        {
-            var rawPoint = rawPoints.Slice(i, 4);
-            results.Add(BitConverter.ToUInt32(rawPoint));
-        }
-
-        // Try to cache this fingerprint.
-        CacheFingerprint(episode, mode, results);
-
-        return results.ToArray();
-    }
-
     /// <summary>
     /// Transforms a Chromaprint into an inverted index of fingerprint points to the last index it appeared at.
     /// </summary>
@@ -295,6 +211,75 @@ public static TimeRange[] DetectSilence(QueuedEpisode episode, int limit)
         return silenceRanges.ToArray();
     }
 
+    /// <summary>
+    /// Gets Chromaprint debugging logs.
+    /// </summary>
+    /// <returns>Markdown formatted logs.</returns>
+    public static string GetChromaprintLogs()
+    {
+        // Print the FFmpeg detection status at the top.
+        // Format: "* FFmpeg: `error`"
+        // Append two newlines to separate the bulleted list from the logs
+        var logs = string.Format(
+            CultureInfo.InvariantCulture,
+            "* FFmpeg: `{0}`\n\n",
+            ChromaprintLogs["error"]);
+
+        // Always include ffmpeg version information
+        logs += FormatFFmpegLog("version");
+
+        // Don't print feature detection logs if the plugin started up okay
+        if (ChromaprintLogs["error"] == "okay")
+        {
+            return logs;
+        }
+
+        // Print all remaining logs
+        foreach (var kvp in ChromaprintLogs)
+        {
+            if (kvp.Key == "error" || kvp.Key == "version")
+            {
+                continue;
+            }
+
+            logs += FormatFFmpegLog(kvp.Key);
+        }
+
+        return logs;
+    }
+
+    /// <summary>
+    /// Run an FFmpeg command with the provided arguments and validate that the output contains
+    /// the provided string.
+    /// </summary>
+    /// <param name="arguments">Arguments to pass to FFmpeg.</param>
+    /// <param name="mustContain">String that the output must contain. Case insensitive.</param>
+    /// <param name="bundleName">Support bundle key to store FFmpeg's output under.</param>
+    /// <param name="errorMessage">Error message to log if this requirement is not met.</param>
+    /// <returns>true on success, false on error.</returns>
+    private static bool CheckFFmpegRequirement(
+        string arguments,
+        string mustContain,
+        string bundleName,
+        string errorMessage)
+    {
+        Logger?.LogDebug("Checking FFmpeg requirement {Arguments}", arguments);
+
+        var output = Encoding.UTF8.GetString(GetOutput(arguments, string.Empty, false, 2000));
+        Logger?.LogTrace("Output of ffmpeg {Arguments}: {Output}", arguments, output);
+        ChromaprintLogs[bundleName] = output;
+
+        if (!output.Contains(mustContain, StringComparison.OrdinalIgnoreCase))
+        {
+            Logger?.LogError("{ErrorMessage}", errorMessage);
+            return false;
+        }
+
+        Logger?.LogDebug("FFmpeg requirement {Arguments} met", arguments);
+
+        return true;
+    }
+
     /// <summary>
     /// Runs ffmpeg and returns standard output (or error).
     /// If caching is enabled, will use cacheFilename to cache the output of this command.
@@ -392,6 +377,58 @@ private static ReadOnlySpan<byte> GetOutput(
         }
     }
 
+    /// <summary>
+    /// Fingerprint a queued episode.
+    /// </summary>
+    /// <param name="episode">Queued episode to fingerprint.</param>
+    /// <param name="mode">Portion of media file to fingerprint.</param>
+    /// <param name="start">Time (in seconds) relative to the start of the file to start fingerprinting from.</param>
+    /// <param name="end">Time (in seconds) relative to the start of the file to stop fingerprinting at.</param>
+    /// <returns>Numerical fingerprint points.</returns>
+    private static uint[] Fingerprint(QueuedEpisode episode, AnalysisMode mode, int start, int end)
+    {
+        // Try to load this episode from cache before running ffmpeg.
+        if (LoadCachedFingerprint(episode, mode, out uint[] cachedFingerprint))
+        {
+            Logger?.LogTrace("Fingerprint cache hit on {File}", episode.Path);
+            return cachedFingerprint;
+        }
+
+        Logger?.LogDebug(
+            "Fingerprinting [{Start}, {End}] from \"{File}\" (id {Id})",
+            start,
+            end,
+            episode.Path,
+            episode.EpisodeId);
+
+        var args = string.Format(
+            CultureInfo.InvariantCulture,
+            "-ss {0} -i \"{1}\" -to {2} -ac 2 -f chromaprint -fp_format raw -",
+            start,
+            episode.Path,
+            end - start);
+
+        // Returns all fingerprint points as raw 32 bit unsigned integers (little endian).
+        var rawPoints = GetOutput(args, string.Empty);
+        if (rawPoints.Length == 0 || rawPoints.Length % 4 != 0)
+        {
+            Logger?.LogWarning("Chromaprint returned {Count} points for \"{Path}\"", rawPoints.Length, episode.Path);
+            throw new FingerprintException("chromaprint output for \"" + episode.Path + "\" was malformed");
+        }
+
+        var results = new List<uint>();
+        for (var i = 0; i < rawPoints.Length; i += 4)
+        {
+            var rawPoint = rawPoints.Slice(i, 4);
+            results.Add(BitConverter.ToUInt32(rawPoint));
+        }
+
+        // Try to cache this fingerprint.
+        CacheFingerprint(episode, mode, results);
+
+        return results.ToArray();
+    }
+
     /// <summary>
     /// Tries to load an episode's fingerprint from cache. If caching is not enabled, calling this function is a no-op.
     /// This function was created before the unified caching mechanism was introduced (in v0.1.7).
@@ -507,43 +544,6 @@ private static string GetFingerprintCachePath(QueuedEpisode episode, AnalysisMod
         }
     }
 
-    /// <summary>
-    /// Gets Chromaprint debugging logs.
-    /// </summary>
-    /// <returns>Markdown formatted logs.</returns>
-    public static string GetChromaprintLogs()
-    {
-        // Print the FFmpeg detection status at the top.
-        // Format: "* FFmpeg: `error`"
-        // Append two newlines to separate the bulleted list from the logs
-        var logs = string.Format(
-            CultureInfo.InvariantCulture,
-            "* FFmpeg: `{0}`\n\n",
-            ChromaprintLogs["error"]);
-
-        // Always include ffmpeg version information
-        logs += FormatFFmpegLog("version");
-
-        // Don't print feature detection logs if the plugin started up okay
-        if (ChromaprintLogs["error"] == "okay")
-        {
-            return logs;
-        }
-
-        // Print all remaining logs
-        foreach (var kvp in ChromaprintLogs)
-        {
-            if (kvp.Key == "error" || kvp.Key == "version")
-            {
-                continue;
-            }
-
-            logs += FormatFFmpegLog(kvp.Key);
-        }
-
-        return logs;
-    }
-
     private static string FormatFFmpegLog(string key)
     {
         /* Format:

From 8ee400f1f1b0e6e1a263787579f32285376e18d6 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 1 Nov 2022 00:53:56 -0500
Subject: [PATCH 04/22] Add blackframe API

---
 .../TestBlackFrames.cs                        |  50 +++++++++++
 .../video/rainbow.mp4                         | Bin 0 -> 15787 bytes
 .../Configuration/PluginConfiguration.cs      |   5 ++
 .../Data/BlackFrame.cs                        |  28 ++++++
 .../FFmpegWrapper.cs                          |  80 ++++++++++++++++--
 5 files changed, 154 insertions(+), 9 deletions(-)
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/rainbow.mp4
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper/Data/BlackFrame.cs

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
new file mode 100644
index 0000000..794ecd1
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
@@ -0,0 +1,50 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper.Tests;
+
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+public class TestBlackFrames
+{
+    [FactSkipFFmpegTests]
+    public void TestBlackFrameDetection()
+    {
+        var expected = new List<BlackFrame>();
+        expected.AddRange(CreateFrameSequence(2, 3));
+        expected.AddRange(CreateFrameSequence(5, 6));
+        expected.AddRange(CreateFrameSequence(8, 9.96));
+
+        var actual = FFmpegWrapper.DetectBlackFrames(
+            queueFile("rainbow.mp4"),
+            new TimeRange(0, 10)
+        );
+
+        for (var i = 0; i < expected.Count; i++)
+        {
+            var (e, a) = (expected[i], actual[i]);
+            Assert.Equal(e.Percentage, a.Percentage);
+            Assert.True(Math.Abs(e.Time - a.Time) <= 0.005);
+        }
+    }
+
+    private QueuedEpisode queueFile(string path)
+    {
+        return new()
+        {
+            EpisodeId = Guid.NewGuid(),
+            Path = "../../../video/" + path
+        };
+    }
+
+    private BlackFrame[] CreateFrameSequence(double start, double end)
+    {
+        var frames = new List<BlackFrame>();
+
+        for (var i = start; i < end; i += 0.04)
+        {
+            frames.Add(new(100, i));
+        }
+
+        return frames.ToArray();
+    }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/rainbow.mp4 b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/rainbow.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..8e01cce620da0f4d72f647169d5f42f3a9b67c08
GIT binary patch
literal 15787
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
W{K%SuP*Bu>Tf=2lKB3$v@ciHQ!_Ged

literal 0
HcmV?d00001

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
index ce79fdd..f4789db 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
@@ -77,6 +77,11 @@ public PluginConfiguration()
     /// </summary>
     public int MaximumEpisodeCreditsDuration { get; set; } = 4;
 
+    /// <summary>
+    /// Gets or sets the minimum percentage of a frame that must consist of black pixels before it is considered a black frame.
+    /// </summary>
+    public int BlackFrameMinimumPercentage { get; set; } = 85;
+
     // ===== Playback settings =====
 
     /// <summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Data/BlackFrame.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Data/BlackFrame.cs
new file mode 100644
index 0000000..df3a957
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Data/BlackFrame.cs
@@ -0,0 +1,28 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper;
+
+/// <summary>
+/// A frame of video that partially (or entirely) consists of black pixels.
+/// </summary>
+public class BlackFrame
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BlackFrame"/> class.
+    /// </summary>
+    /// <param name="percent">Percentage of the frame that is black.</param>
+    /// <param name="time">Time this frame appears at.</param>
+    public BlackFrame(int percent, double time)
+    {
+        Percentage = percent;
+        Time = time;
+    }
+
+    /// <summary>
+    /// Gets or sets the percentage of the frame that is black.
+    /// </summary>
+    public int Percentage { get; set; }
+
+    /// <summary>
+    /// Gets or sets the time (in seconds) this frame appeared at.
+    /// </summary>
+    public double Time { get; set; }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
index 66fc68b..e8ba464 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
@@ -16,16 +16,17 @@ public static class FFmpegWrapper
 {
     private static readonly object InvertedIndexCacheLock = new();
 
-    // FFmpeg logs lines similar to the following:
-    // [silencedetect @ 0x000000000000] silence_start: 12.34
-    // [silencedetect @ 0x000000000000] silence_end: 56.123 | silence_duration: 43.783
-
     /// <summary>
     /// Used with FFmpeg's silencedetect filter to extract the start and end times of silence.
     /// </summary>
     private static readonly Regex SilenceDetectionExpression = new(
         "silence_(?<type>start|end): (?<time>[0-9\\.]+)");
 
+    /// <summary>
+    /// Used with FFmpeg's blackframe filter to extract the time and percentage of black pixels.
+    /// </summary>
+    private static readonly Regex BlackFrameRegex = new("(pblack|t):[0-9.]+");
+
     /// <summary>
     /// Gets or sets the logger.
     /// </summary>
@@ -190,7 +191,12 @@ public static TimeRange[] DetectSilence(QueuedEpisode episode, int limit)
         var currentRange = new TimeRange();
         var silenceRanges = new List<TimeRange>();
 
-        // Each match will have a type (either "start" or "end") and a timecode (a double).
+        /* Each match will have a type (either "start" or "end") and a timecode (a double).
+         *
+         * Sample output:
+         * [silencedetect @ 0x000000000000] silence_start: 12.34
+         * [silencedetect @ 0x000000000000] silence_end: 56.123 | silence_duration: 43.783
+        */
         var raw = Encoding.UTF8.GetString(GetOutput(args, cacheKey, true));
         foreach (Match match in SilenceDetectionExpression.Matches(raw))
         {
@@ -211,6 +217,61 @@ public static TimeRange[] DetectSilence(QueuedEpisode episode, int limit)
         return silenceRanges.ToArray();
     }
 
+    /// <summary>
+    /// Finds the location of all black frames in a media file within a time range.
+    /// </summary>
+    /// <param name="episode">Media file to analyze.</param>
+    /// <param name="range">Time range to search.</param>
+    /// <returns>Array of frames that are at least 50% black.</returns>
+    public static BlackFrame[] DetectBlackFrames(QueuedEpisode episode, TimeRange range)
+    {
+        // Seek to the start of the time range and find frames that are at least 50% black.
+        var args = string.Format(
+            CultureInfo.InvariantCulture,
+            "-ss {0} -i \"{1}\" -to {2} -an -dn -sn -vf \"blackframe=amount=50\" -f null -",
+            range.Start,
+            episode.Path,
+            range.End - range.Start);
+
+        // Cache the results to GUID-blackframes-v1-START-END.
+        var cacheKey = string.Format(
+            CultureInfo.InvariantCulture,
+            "{0}-blackframes-v1-{1}-{2}",
+            episode.EpisodeId.ToString("N"),
+            range.Start,
+            range.End);
+
+        var blackFrames = new List<BlackFrame>();
+
+        /* Run the blackframe filter.
+         *
+         * Sample output:
+         * [Parsed_blackframe_0 @ 0x0000000] frame:1 pblack:99 pts:43 t:0.043000 type:B last_keyframe:0
+         * [Parsed_blackframe_0 @ 0x0000000] frame:2 pblack:99 pts:85 t:0.085000 type:B last_keyframe:0
+         */
+        var raw = Encoding.UTF8.GetString(GetOutput(args, cacheKey, true));
+        foreach (var line in raw.Split('\n'))
+        {
+            var matches = BlackFrameRegex.Matches(line);
+            if (matches.Count != 2)
+            {
+                continue;
+            }
+
+            var (strPercent, strTime) = (
+                matches[0].Value.Split(':')[1],
+                matches[1].Value.Split(':')[1]
+            );
+
+            blackFrames.Add(new(
+                Convert.ToInt32(strPercent, CultureInfo.InvariantCulture),
+                Convert.ToDouble(strTime, CultureInfo.InvariantCulture)
+            ));
+        }
+
+        return blackFrames.ToArray();
+    }
+
     /// <summary>
     /// Gets Chromaprint debugging logs.
     /// </summary>
@@ -296,10 +357,11 @@ private static ReadOnlySpan<byte> GetOutput(
     {
         var ffmpegPath = Plugin.Instance?.FFmpegPath ?? "ffmpeg";
 
-        // The silencedetect filter outputs silence timestamps at the info log level.
-        var logLevel = args.Contains("silencedetect", StringComparison.OrdinalIgnoreCase) ?
-            "info" :
-            "warning";
+        // The silencedetect and blackframe filters output data at the info log level.
+        var useInfoLevel = args.Contains("silencedetect", StringComparison.OrdinalIgnoreCase) ||
+            args.Contains("blackframe", StringComparison.OrdinalIgnoreCase);
+
+        var logLevel = useInfoLevel ? "info" : "warning";
 
         var cacheOutput =
             (Plugin.Instance?.Configuration.CacheFingerprints ?? false) &&

From ce3e1a5c496327dc639c96110c319f8006d90bb6 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Wed, 2 Nov 2022 02:57:19 -0500
Subject: [PATCH 05/22] Rename ChromaprintAnalyzer.cs

---
 .../Analyzers/{Chromaprint.cs => ChromaprintAnalyzer.cs}          | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/{Chromaprint.cs => ChromaprintAnalyzer.cs} (100%)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs
similarity index 100%
rename from ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/Chromaprint.cs
rename to ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs

From 2bd972f3a37be8d8573070ab32426cfe6b9caad0 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Wed, 2 Nov 2022 17:06:21 -0500
Subject: [PATCH 06/22] Add black frame analyzer

---
 .../TestBlackFrames.cs                        |  30 ++++-
 .../video/credits.mp4                         | Bin 0 -> 242246 bytes
 .../Analyzers/BlackFrameAnalyzer.cs           | 125 ++++++++++++++++++
 .../FFmpegWrapper.cs                          |  22 ++-
 .../ScheduledTasks/DetectCreditsTask.cs       |  52 +++++---
 5 files changed, 195 insertions(+), 34 deletions(-)
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/credits.mp4
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
index 794ecd1..bdd34e5 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
@@ -2,6 +2,7 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper.Tests;
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
 using Xunit;
 
 public class TestBlackFrames
@@ -9,29 +10,42 @@ public class TestBlackFrames
     [FactSkipFFmpegTests]
     public void TestBlackFrameDetection()
     {
+        var range = 1e-5;
+
         var expected = new List<BlackFrame>();
         expected.AddRange(CreateFrameSequence(2, 3));
         expected.AddRange(CreateFrameSequence(5, 6));
         expected.AddRange(CreateFrameSequence(8, 9.96));
 
-        var actual = FFmpegWrapper.DetectBlackFrames(
-            queueFile("rainbow.mp4"),
-            new TimeRange(0, 10)
-        );
+        var actual = FFmpegWrapper.DetectBlackFrames(queueFile("rainbow.mp4"), new(0, 10), 85);
 
         for (var i = 0; i < expected.Count; i++)
         {
             var (e, a) = (expected[i], actual[i]);
             Assert.Equal(e.Percentage, a.Percentage);
-            Assert.True(Math.Abs(e.Time - a.Time) <= 0.005);
+            Assert.InRange(a.Time, e.Time - range, e.Time + range);
         }
     }
 
+    [FactSkipFFmpegTests]
+    public void TestEndCreditDetection()
+    {
+        var analyzer = CreateBlackFrameAnalyzer();
+
+        var episode = queueFile("credits.mp4");
+        episode.Duration = (int)new TimeSpan(0, 5, 30).TotalSeconds;
+
+        var result = analyzer.AnalyzeMediaFile(episode, AnalysisMode.Credits, 85);
+        Assert.NotNull(result);
+        Assert.Equal(300, result.IntroStart);
+    }
+
     private QueuedEpisode queueFile(string path)
     {
         return new()
         {
             EpisodeId = Guid.NewGuid(),
+            Name = path,
             Path = "../../../video/" + path
         };
     }
@@ -47,4 +61,10 @@ private BlackFrame[] CreateFrameSequence(double start, double end)
 
         return frames.ToArray();
     }
+
+    private BlackFrameAnalyzer CreateBlackFrameAnalyzer()
+    {
+        var logger = new LoggerFactory().CreateLogger<BlackFrameAnalyzer>();
+        return new(logger);
+    }
 }
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/credits.mp4 b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/video/credits.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..c8fa8d277fb92ab65b493ba893208238f6caeb97
GIT binary patch
literal 242246
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

literal 0
HcmV?d00001

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
new file mode 100644
index 0000000..1c28c5f
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
@@ -0,0 +1,125 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+
+/// <summary>
+/// Media file analyzer used to detect end credits that consist of text overlaid on a black background.
+/// Bisects the end of the video file to perform an efficient search.
+/// </summary>
+public class BlackFrameAnalyzer : IMediaFileAnalyzer
+{
+    private readonly TimeSpan _maximumError = new(0, 0, 4);
+
+    private readonly ILogger<BlackFrameAnalyzer> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BlackFrameAnalyzer"/> class.
+    /// </summary>
+    /// <param name="logger">Logger.</param>
+    public BlackFrameAnalyzer(ILogger<BlackFrameAnalyzer> logger)
+    {
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
+        ReadOnlyCollection<QueuedEpisode> analysisQueue,
+        AnalysisMode mode,
+        CancellationToken cancellationToken)
+    {
+        if (mode != AnalysisMode.Credits)
+        {
+            throw new NotImplementedException("mode must equal Credits");
+        }
+
+        var creditTimes = new Dictionary<Guid, Intro>();
+
+        foreach (var episode in analysisQueue)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+
+            var intro = AnalyzeMediaFile(
+                episode,
+                mode,
+                Plugin.Instance!.Configuration.BlackFrameMinimumPercentage);
+
+            if (intro is null)
+            {
+                continue;
+            }
+
+            creditTimes[episode.EpisodeId] = intro;
+        }
+
+        Plugin.Instance!.UpdateTimestamps(creditTimes, mode);
+
+        return analysisQueue
+            .Where(x => !creditTimes.ContainsKey(x.EpisodeId))
+            .ToList()
+            .AsReadOnly();
+    }
+
+    /// <summary>
+    /// Analyzes an individual media file. Only public because of unit tests.
+    /// </summary>
+    /// <param name="episode">Media file to analyze.</param>
+    /// <param name="mode">Analysis mode.</param>
+    /// <param name="minimum">Percentage of the frame that must be black.</param>
+    /// <returns>Credits timestamp.</returns>
+    public Intro? AnalyzeMediaFile(QueuedEpisode episode, AnalysisMode mode, int minimum)
+    {
+        // Start by analyzing the last four minutes of the file.
+        var start = TimeSpan.FromMinutes(4);
+        var end = TimeSpan.Zero;
+        var firstFrameTime = 0.0;
+
+        // Continue bisecting the end of the file until the range that contains the first black
+        // frame is smaller than the maximum permitted error.
+        while (start - end > _maximumError)
+        {
+            // Analyze the middle two seconds from the current bisected range
+            var midpoint = (start + end) / 2;
+            var scanTime = episode.Duration - midpoint.TotalSeconds;
+            var tr = new TimeRange(scanTime, scanTime + 2);
+
+            _logger.LogTrace(
+                "{Episode}, dur {Duration}, bisect [{BStart}, {BEnd}], time [{Start}, {End}]",
+                episode.Name,
+                episode.Duration,
+                start,
+                end,
+                tr.Start,
+                tr.End);
+
+            var frames = FFmpegWrapper.DetectBlackFrames(episode, tr, minimum);
+            _logger.LogTrace("{Episode}, black frames: {Count}", episode.Name, frames.Length);
+
+            if (frames.Length == 0)
+            {
+                // Since no black frames were found, slide the range closer to the end
+                start = midpoint;
+            }
+            else
+            {
+                // Some black frames were found, slide the range closer to the start
+                end = midpoint;
+                firstFrameTime = frames[0].Time + scanTime;
+            }
+        }
+
+        if (firstFrameTime > 0)
+        {
+            return new(episode.EpisodeId, new TimeRange(firstFrameTime, episode.Duration));
+        }
+
+        return null;
+    }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
index e8ba464..1cb2c4d 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/FFmpegWrapper.cs
@@ -222,8 +222,12 @@ public static TimeRange[] DetectSilence(QueuedEpisode episode, int limit)
     /// </summary>
     /// <param name="episode">Media file to analyze.</param>
     /// <param name="range">Time range to search.</param>
-    /// <returns>Array of frames that are at least 50% black.</returns>
-    public static BlackFrame[] DetectBlackFrames(QueuedEpisode episode, TimeRange range)
+    /// <param name="minimum">Percentage of the frame that must be black.</param>
+    /// <returns>Array of frames that are mostly black.</returns>
+    public static BlackFrame[] DetectBlackFrames(
+        QueuedEpisode episode,
+        TimeRange range,
+        int minimum)
     {
         // Seek to the start of the time range and find frames that are at least 50% black.
         var args = string.Format(
@@ -233,10 +237,10 @@ public static BlackFrame[] DetectBlackFrames(QueuedEpisode episode, TimeRange ra
             episode.Path,
             range.End - range.Start);
 
-        // Cache the results to GUID-blackframes-v1-START-END.
+        // Cache the results to GUID-blackframes-START-END-v1.
         var cacheKey = string.Format(
             CultureInfo.InvariantCulture,
-            "{0}-blackframes-v1-{1}-{2}",
+            "{0}-blackframes-{1}-{2}-v1",
             episode.EpisodeId.ToString("N"),
             range.Start,
             range.End);
@@ -263,10 +267,14 @@ public static BlackFrame[] DetectBlackFrames(QueuedEpisode episode, TimeRange ra
                 matches[1].Value.Split(':')[1]
             );
 
-            blackFrames.Add(new(
+            var bf = new BlackFrame(
                 Convert.ToInt32(strPercent, CultureInfo.InvariantCulture),
-                Convert.ToDouble(strTime, CultureInfo.InvariantCulture)
-            ));
+                Convert.ToDouble(strTime, CultureInfo.InvariantCulture));
+
+            if (bf.Percentage > minimum)
+            {
+                blackFrames.Add(bf);
+            }
         }
 
         return blackFrames.ToArray();
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index 224155f..d4da24e 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -122,10 +122,8 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
                     return;
                 }
 
-                // Increment totalProcessed by the number of episodes in this season that were actually analyzed
-                // (instead of just using the number of episodes in the current season).
-                var analyzed = AnalyzeSeason(episodes, cancellationToken);
-                Interlocked.Add(ref totalProcessed, analyzed);
+                AnalyzeSeason(episodes, cancellationToken);
+                Interlocked.Add(ref totalProcessed, episodes.Count);
             }
             catch (FingerprintException ex)
             {
@@ -151,39 +149,49 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
     }
 
     /// <summary>
-    /// Fingerprints all episodes in the provided season and stores the timestamps of all introductions.
+    /// Analyzes all episodes in the season for end credits.
     /// </summary>
     /// <param name="episodes">Episodes in this season.</param>
     /// <param name="cancellationToken">Cancellation token provided by the scheduled task.</param>
-    /// <returns>Number of episodes from the provided season that were analyzed.</returns>
-    private int AnalyzeSeason(
+    private void AnalyzeSeason(
         ReadOnlyCollection<QueuedEpisode> episodes,
         CancellationToken cancellationToken)
     {
-        // Skip seasons with an insufficient number of episodes.
-        if (episodes.Count <= 1)
+        // Only analyze specials (season 0) if the user has opted in.
+        if (episodes[0].SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
         {
-            return episodes.Count;
+            return;
         }
 
-        // Only analyze specials (season 0) if the user has opted in.
-        var first = episodes[0];
-        if (first.SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
+        // Analyze with Chromaprint first and fall back to the black frame detector
+        var analyzers = new IMediaFileAnalyzer[]
+        {
+            // TODO: FIXME: new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>()),
+            new BlackFrameAnalyzer(_loggerFactory.CreateLogger<BlackFrameAnalyzer>())
+        };
+
+        // Use each analyzer to find credits in all media files, removing successfully analyzed files
+        // from the queue.
+        var remaining = new ReadOnlyCollection<QueuedEpisode>(episodes);
+        foreach (var analyzer in analyzers)
         {
-            return 0;
+            remaining = AnalyzeFiles(remaining, analyzer, cancellationToken);
         }
+    }
 
+    private ReadOnlyCollection<QueuedEpisode> AnalyzeFiles(
+        ReadOnlyCollection<QueuedEpisode> episodes,
+        IMediaFileAnalyzer analyzer,
+        CancellationToken cancellationToken)
+    {
         _logger.LogInformation(
-            "Analyzing {Count} episodes from {Name} season {Season}",
+            "Analyzing {Count} episodes from {Name} season {Season} with {Analyzer}",
             episodes.Count,
-            first.SeriesName,
-            first.SeasonNumber);
-
-        // Analyze the season with Chromaprint
-        var chromaprint = new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>());
-        chromaprint.AnalyzeMediaFiles(episodes, AnalysisMode.Credits, cancellationToken);
+            episodes[0].SeriesName,
+            episodes[0].SeasonNumber,
+            analyzer.GetType().Name);
 
-        return episodes.Count;
+        return analyzer.AnalyzeMediaFiles(episodes, AnalysisMode.Credits, cancellationToken);
     }
 
     /// <summary>

From 546bf7578c0e0c0be9c2bd8866f6738db5a6b806 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Wed, 2 Nov 2022 17:07:45 -0500
Subject: [PATCH 07/22] Rename DetectIntroductionsTask.cs

---
 ...EpisodesTask.cs => DetectIntroductionsTask.cs} | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)
 rename ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/{AnalyzeEpisodesTask.cs => DetectIntroductionsTask.cs} (94%)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
similarity index 94%
rename from ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs
rename to ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 6d563fc..416cd80 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/AnalyzeEpisodesTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -12,22 +12,21 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 
 /// <summary>
 /// Analyze all television episodes for introduction sequences.
-/// TODO: FIXME: rename task and file to DetectIntroductionsTask.
 /// </summary>
-public class AnalyzeEpisodesTask : IScheduledTask
+public class DetectIntroductionsTask : IScheduledTask
 {
-    private readonly ILogger<AnalyzeEpisodesTask> _logger;
+    private readonly ILogger<DetectIntroductionsTask> _logger;
 
     private readonly ILoggerFactory _loggerFactory;
 
     private readonly ILibraryManager? _libraryManager;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="AnalyzeEpisodesTask"/> class.
+    /// Initializes a new instance of the <see cref="DetectIntroductionsTask"/> class.
     /// </summary>
     /// <param name="loggerFactory">Logger factory.</param>
     /// <param name="libraryManager">Library manager.</param>
-    public AnalyzeEpisodesTask(
+    public DetectIntroductionsTask(
         ILoggerFactory loggerFactory,
         ILibraryManager libraryManager) : this(loggerFactory)
     {
@@ -35,12 +34,12 @@ public AnalyzeEpisodesTask(
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="AnalyzeEpisodesTask"/> class.
+    /// Initializes a new instance of the <see cref="DetectIntroductionsTask"/> class.
     /// </summary>
     /// <param name="loggerFactory">Logger factory.</param>
-    public AnalyzeEpisodesTask(ILoggerFactory loggerFactory)
+    public DetectIntroductionsTask(ILoggerFactory loggerFactory)
     {
-        _logger = loggerFactory.CreateLogger<AnalyzeEpisodesTask>();
+        _logger = loggerFactory.CreateLogger<DetectIntroductionsTask>();
         _loggerFactory = loggerFactory;
 
         EdlManager.Initialize(_logger);

From 2c3577ea23fbf7fa827226a20ce11288b04f3c14 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 8 Nov 2022 20:55:23 -0600
Subject: [PATCH 08/22] Change skip button selector

---
 .../e2e_tests/selenium/main.py                                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/selenium/main.py b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/selenium/main.py
index e602cd8..ceaa25b 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/selenium/main.py
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/selenium/main.py
@@ -152,7 +152,7 @@ def test_skip_button(driver, server):
 
     # Find the skip intro button and click it, logging the new video position after the seek is preformed
     print("  [+] Clicking skip intro button")
-    driver.find_element(By.CSS_SELECTOR, "button.btnSkipIntro").click()
+    driver.find_element(By.CSS_SELECTOR, "div#skipIntro").click()
     time.sleep(1)
     screenshot(driver, "skip_button_post_skip")
     assert_video_playing(driver)

From bcb5e5ea300c9e4a3efe3c9517d937ab6667e065 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Wed, 23 Nov 2022 02:34:28 -0600
Subject: [PATCH 09/22] Remove dependency on shared media item queue

---
 .../Controllers/TroubleshootingController.cs  |  5 +--
 .../Controllers/VisualizationController.cs    |  8 ++---
 .../Entrypoint.cs                             |  7 +---
 .../Plugin.cs                                 |  4 +--
 .../QueueManager.cs                           | 34 +++++++++++--------
 .../ScheduledTasks/DetectCreditsTask.cs       | 10 +++---
 .../ScheduledTasks/DetectIntroductionsTask.cs | 10 +++---
 7 files changed, 38 insertions(+), 40 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/TroubleshootingController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/TroubleshootingController.cs
index 8923daf..1b1b901 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/TroubleshootingController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/TroubleshootingController.cs
@@ -53,10 +53,7 @@ public ActionResult<string> GetSupportBundle()
 
         bundle.Append("* Queue contents: ");
         bundle.Append(Plugin.Instance!.TotalQueued);
-        bundle.Append(" episodes, ");
-        bundle.Append(Plugin.Instance!.AnalysisQueue.Count);
-        bundle.Append(" seasons");
-        bundle.Append('\n');
+        bundle.Append(" episodes\n");
 
         bundle.Append(FFmpegWrapper.GetChromaprintLogs());
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
index f2331ab..daef672 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/VisualizationController.cs
@@ -40,7 +40,7 @@ public ActionResult<Dictionary<string, HashSet<string>>> GetShowSeasons()
         var showSeasons = new Dictionary<string, HashSet<string>>();
 
         // Loop through all seasons in the analysis queue
-        foreach (var kvp in Plugin.Instance!.AnalysisQueue)
+        foreach (var kvp in Plugin.Instance!.QueuedMediaItems)
         {
             // Check that this season contains at least one episode.
             var episodes = kvp.Value;
@@ -104,10 +104,8 @@ public ActionResult<List<EpisodeVisualization>> GetSeasonEpisodes(
     [HttpGet("Episode/{Id}/Chromaprint")]
     public ActionResult<uint[]> GetEpisodeFingerprint([FromRoute] Guid id)
     {
-        var queue = Plugin.Instance!.AnalysisQueue;
-
         // Search through all queued episodes to find the requested id
-        foreach (var season in queue)
+        foreach (var season in Plugin.Instance!.QueuedMediaItems)
         {
             foreach (var needle in season.Value)
             {
@@ -180,7 +178,7 @@ private string GetSeasonName(QueuedEpisode episode)
     /// <returns>Boolean indicating if the requested season was found.</returns>
     private bool LookupSeasonByName(string series, string season, out List<QueuedEpisode> episodes)
     {
-        foreach (var queuedEpisodes in Plugin.Instance!.AnalysisQueue)
+        foreach (var queuedEpisodes in Plugin.Instance!.QueuedMediaItems)
         {
             var first = queuedEpisodes.Value[0];
             var firstSeasonName = GetSeasonName(first);
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
index 6a5dff2..a7a176a 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
@@ -57,7 +57,7 @@ public Task RunAsync()
 
         try
         {
-            // Enqueue all episodes at startup so the fingerprint visualizer works before the task is started.
+            // Enqueue all episodes at startup to ensure any FFmpeg errors appear as early as possible
             _logger.LogInformation("Running startup enqueue");
             var queueManager = new QueueManager(_loggerFactory.CreateLogger<QueueManager>(), _libraryManager);
             queueManager.EnqueueAllEpisodes();
@@ -67,11 +67,6 @@ public Task RunAsync()
             _logger.LogError("Unable to run startup enqueue: {Exception}", ex);
         }
 
-        _logger.LogDebug(
-            "Total enqueued seasons: {Count} ({Episodes} episodes)",
-            Plugin.Instance!.AnalysisQueue.Count,
-            Plugin.Instance!.TotalQueued);
-
         return Task.CompletedTask;
     }
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
index bf5d241..84ea81c 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
@@ -92,9 +92,9 @@ public Plugin(
     public Dictionary<Guid, Intro> Intros { get; } = new();
 
     /// <summary>
-    /// Gets the mapping of season ids to episodes that have been queued for fingerprinting.
+    /// Gets the most recent media item queue.
     /// </summary>
-    public Dictionary<Guid, List<QueuedEpisode>> AnalysisQueue { get; } = new();
+    public Dictionary<Guid, List<QueuedEpisode>> QueuedMediaItems { get; } = new();
 
     /// <summary>
     /// Gets or sets the total number of episodes in the queue.
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
index be905e6..4f3308f 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
@@ -2,12 +2,12 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.Entities;
 using Microsoft.Extensions.Logging;
 
 /// <summary>
@@ -19,7 +19,8 @@ public class QueueManager
     private ILogger<QueueManager> _logger;
 
     private double analysisPercent;
-    private IList<string> selectedLibraries;
+    private List<string> selectedLibraries;
+    private Dictionary<Guid, List<QueuedEpisode>> _queuedEpisodes;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="QueueManager"/> class.
@@ -31,13 +32,15 @@ public QueueManager(ILogger<QueueManager> logger, ILibraryManager libraryManager
         _logger = logger;
         _libraryManager = libraryManager;
 
-        selectedLibraries = new List<string>();
+        selectedLibraries = new();
+        _queuedEpisodes = new();
     }
 
     /// <summary>
     /// Iterates through all libraries on the server and queues all episodes for analysis.
     /// </summary>
-    public void EnqueueAllEpisodes()
+    /// <returns>Queued media items.</returns>
+    public ReadOnlyDictionary<Guid, List<QueuedEpisode>> EnqueueAllEpisodes()
     {
         // Assert that ffmpeg with chromaprint is installed
         if (!FFmpegWrapper.CheckFFmpegVersion())
@@ -46,20 +49,13 @@ public void EnqueueAllEpisodes()
                 "ffmpeg with chromaprint is not installed on this system - episodes will not be analyzed. If Jellyfin is running natively, install jellyfin-ffmpeg5. If Jellyfin is running in a container, upgrade it to the latest version of 10.8.0.");
         }
 
-        Plugin.Instance!.AnalysisQueue.Clear();
         Plugin.Instance!.TotalQueued = 0;
 
         LoadAnalysisSettings();
 
-        // For all selected TV show libraries, enqueue all contained items.
+        // For all selected libraries, enqueue all contained episodes.
         foreach (var folder in _libraryManager.GetVirtualFolders())
         {
-            if (folder.CollectionType != CollectionTypeOptions.TvShows)
-            {
-                _logger.LogDebug("Not analyzing library \"{Name}\": not a TV show library", folder.Name);
-                continue;
-            }
-
             // If libraries have been selected for analysis, ensure this library was selected.
             if (selectedLibraries.Count > 0 && !selectedLibraries.Contains(folder.Name))
             {
@@ -81,6 +77,14 @@ public void EnqueueAllEpisodes()
                 _logger.LogError("Failed to enqueue items from library {Name}: {Exception}", folder.Name, ex);
             }
         }
+
+        Plugin.Instance!.QueuedMediaItems.Clear();
+        foreach (var kvp in _queuedEpisodes)
+        {
+            Plugin.Instance!.QueuedMediaItems[kvp.Key] = kvp.Value;
+        }
+
+        return new(_queuedEpisodes);
     }
 
     /// <summary>
@@ -156,7 +160,7 @@ private void QueueLibraryContents(string rawId)
         {
             if (item is not Episode episode)
             {
-                _logger.LogError("Item {Name} is not an episode", item.Name);
+                _logger.LogDebug("Item {Name} is not an episode", item.Name);
                 continue;
             }
 
@@ -198,11 +202,11 @@ private void QueueEpisode(Episode episode)
             60 * Plugin.Instance!.Configuration.AnalysisLengthLimit);
 
         // Allocate a new list for each new season
-        Plugin.Instance!.AnalysisQueue.TryAdd(episode.SeasonId, new List<QueuedEpisode>());
+        _queuedEpisodes.TryAdd(episode.SeasonId, new List<QueuedEpisode>());
 
         // Queue the episode for analysis
         var maxCreditsDuration = Plugin.Instance!.Configuration.MaximumEpisodeCreditsDuration * 60;
-        Plugin.Instance.AnalysisQueue[episode.SeasonId].Add(new QueuedEpisode()
+        _queuedEpisodes[episode.SeasonId].Add(new QueuedEpisode()
         {
             SeriesName = episode.SeriesName,
             SeasonNumber = episode.AiredSeasonNumber ?? 0,
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index d4da24e..92f9bbc 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -84,9 +84,7 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             _loggerFactory.CreateLogger<QueueManager>(),
             _libraryManager);
 
-        queueManager.EnqueueAllEpisodes();
-
-        var queue = Plugin.Instance!.AnalysisQueue;
+        var queue = queueManager.EnqueueAllEpisodes();
 
         if (queue.Count == 0)
         {
@@ -142,7 +140,11 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
                     ex);
             }
 
-            progress.Report((totalProcessed * 100) / Plugin.Instance!.TotalQueued);
+            var total = Plugin.Instance!.TotalQueued;
+            if (total > 0)
+            {
+                progress.Report((totalProcessed * 100) / total);
+            }
         });
 
         return Task.CompletedTask;
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 416cd80..5b232b8 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -83,9 +83,7 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             _loggerFactory.CreateLogger<QueueManager>(),
             _libraryManager);
 
-        queueManager.EnqueueAllEpisodes();
-
-        var queue = Plugin.Instance!.AnalysisQueue;
+        var queue = queueManager.EnqueueAllEpisodes();
 
         if (queue.Count == 0)
         {
@@ -162,7 +160,11 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
                 EdlManager.UpdateEDLFiles(episodes);
             }
 
-            progress.Report((totalProcessed * 100) / Plugin.Instance!.TotalQueued);
+            var total = Plugin.Instance!.TotalQueued;
+            if (total > 0)
+            {
+                progress.Report((totalProcessed * 100) / total);
+            }
         });
 
         // Turn the regenerate EDL flag off after the scan completes.

From a68914ca8f74ad82e62844054aa6dd00ac7eec7c Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Thu, 24 Nov 2022 00:43:23 -0600
Subject: [PATCH 10/22] Add chapter name based media file analyzer

Closes #58
---
 .../TestChapterAnalyzer.cs                    |  83 +++++++++++
 .../Analyzers/ChapterAnalyzer.cs              | 138 ++++++++++++++++++
 .../Analyzers/ChromaprintAnalyzer.cs          |   1 -
 .../Configuration/PluginConfiguration.cs      |  16 +-
 .../Controllers/SkipIntroController.cs        |  14 +-
 .../Plugin.cs                                 | 119 ++++++++-------
 .../ScheduledTasks/DetectCreditsTask.cs       |   3 -
 .../ScheduledTasks/DetectIntroductionsTask.cs |   4 +
 8 files changed, 312 insertions(+), 66 deletions(-)
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
new file mode 100644
index 0000000..e1da0ab
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
@@ -0,0 +1,83 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper.Tests;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+public class TestChapterAnalyzer
+{
+    [Theory]
+    [InlineData("Opening")]
+    [InlineData("OP")]
+    [InlineData("Intro")]
+    [InlineData("Intro Start")]
+    [InlineData("Introduction")]
+    public void TestIntroductionExpression(string chapterName)
+    {
+        var chapters = CreateChapters(chapterName, AnalysisMode.Introduction);
+        var introChapter = FindChapter(chapters, AnalysisMode.Introduction);
+
+        Assert.NotNull(introChapter);
+        Assert.Equal(60, introChapter.IntroStart);
+        Assert.Equal(90, introChapter.IntroEnd);
+    }
+
+    [Theory]
+    [InlineData("End Credits")]
+    [InlineData("Ending")]
+    [InlineData("Credit start")]
+    [InlineData("Closing Credits")]
+    [InlineData("Credits")]
+    public void TestEndCreditsExpression(string chapterName)
+    {
+        var chapters = CreateChapters(chapterName, AnalysisMode.Credits);
+        var creditsChapter = FindChapter(chapters, AnalysisMode.Credits);
+
+        Assert.NotNull(creditsChapter);
+        Assert.Equal(1890, creditsChapter.IntroStart);
+        Assert.Equal(2000, creditsChapter.IntroEnd);
+    }
+
+    private Intro? FindChapter(Collection<ChapterInfo> chapters, AnalysisMode mode)
+    {
+        var logger = new LoggerFactory().CreateLogger<ChapterAnalyzer>();
+        var analyzer = new ChapterAnalyzer(logger);
+
+        var config = new Configuration.PluginConfiguration();
+        var expression = mode == AnalysisMode.Introduction ?
+            config.ChapterAnalyzerIntroductionPattern :
+            config.ChapterAnalyzerEndCreditsPattern;
+
+        return analyzer.FindMatchingChapter(Guid.Empty, 2000, chapters, expression, mode);
+    }
+
+    private Collection<ChapterInfo> CreateChapters(string name, AnalysisMode mode)
+    {
+        var chapters = new[]{
+            CreateChapter("Cold Open", 0),
+            CreateChapter(mode == AnalysisMode.Introduction ? name : "Introduction", 60),
+            CreateChapter("Main Episode", 90),
+            CreateChapter(mode == AnalysisMode.Credits ? name : "Credits", 1890)
+        };
+
+        return new(new List<ChapterInfo>(chapters));
+    }
+
+    /// <summary>
+    /// Create a ChapterInfo object.
+    /// </summary>
+    /// <param name="name">Chapter name.</param>
+    /// <param name="position">Chapter position (in seconds).</param>
+    /// <returns>ChapterInfo.</returns>
+    private ChapterInfo CreateChapter(string name, int position)
+    {
+        return new()
+        {
+            Name = name,
+            StartPositionTicks = TimeSpan.FromSeconds(position).Ticks
+        };
+    }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
new file mode 100644
index 0000000..86efd53
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
@@ -0,0 +1,138 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using MediaBrowser.Model.Entities;
+
+/// <summary>
+/// Chapter name analyzer.
+/// </summary>
+public class ChapterAnalyzer : IMediaFileAnalyzer
+{
+    private ILogger<ChapterAnalyzer> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChapterAnalyzer"/> class.
+    /// </summary>
+    /// <param name="logger">Logger.</param>
+    public ChapterAnalyzer(ILogger<ChapterAnalyzer> logger)
+    {
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
+        ReadOnlyCollection<QueuedEpisode> analysisQueue,
+        AnalysisMode mode,
+        CancellationToken cancellationToken)
+    {
+        var skippableRanges = new Dictionary<Guid, Intro>();
+        var expression = mode == AnalysisMode.Introduction ?
+            Plugin.Instance!.Configuration.ChapterAnalyzerIntroductionPattern :
+            Plugin.Instance!.Configuration.ChapterAnalyzerEndCreditsPattern;
+
+        foreach (var episode in analysisQueue)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+
+            var skipRange = FindMatchingChapter(
+                episode.EpisodeId,
+                episode.Duration,
+                new(Plugin.Instance!.GetChapters(episode.EpisodeId)),
+                expression,
+                mode);
+
+            if (skipRange is null)
+            {
+                continue;
+            }
+
+            skippableRanges.Add(episode.EpisodeId, skipRange);
+        }
+
+        Plugin.Instance!.UpdateTimestamps(skippableRanges, mode);
+
+        return analysisQueue;
+    }
+
+    /// <summary>
+    /// Searches a list of chapter names for one that matches the provided regular expression.
+    /// Only public to allow for unit testing.
+    /// </summary>
+    /// <param name="id">Item id.</param>
+    /// <param name="duration">Duration of media file in seconds.</param>
+    /// <param name="chapters">Media item chapters.</param>
+    /// <param name="expression">Regular expression pattern.</param>
+    /// <param name="mode">Analysis mode.</param>
+    /// <returns>Intro object containing skippable time range, or null if no chapter matched.</returns>
+    public Intro? FindMatchingChapter(
+        Guid id,
+        int duration,
+        Collection<ChapterInfo> chapters,
+        string expression,
+        AnalysisMode mode)
+    {
+        Intro? matchingChapter = null;
+
+        var config = Plugin.Instance?.Configuration ?? new Configuration.PluginConfiguration();
+        var minDuration = config.MinimumIntroDuration;
+        int maxDuration = mode == AnalysisMode.Introduction ?
+            config.MaximumIntroDuration :
+            config.MaximumEpisodeCreditsDuration;
+
+        if (mode == AnalysisMode.Credits)
+        {
+            // Since the ending credits chapter may be the last chapter in the file, append a virtual
+            // chapter at the very end of the file.
+            chapters.Add(new ChapterInfo()
+            {
+                StartPositionTicks = TimeSpan.FromSeconds(duration).Ticks
+            });
+        }
+
+        // Check all chapters
+        for (int i = 0; i < chapters.Count - 1; i++)
+        {
+            // Calculate chapter position and duration
+            var current = chapters[i];
+            var next = chapters[i + 1];
+
+            var currentRange = new TimeRange(
+                TimeSpan.FromTicks(current.StartPositionTicks).TotalSeconds,
+                TimeSpan.FromTicks(next.StartPositionTicks).TotalSeconds);
+
+            // Skip chapters with that don't have a name or are too short/long
+            if (string.IsNullOrEmpty(current.Name) ||
+                currentRange.Duration < minDuration ||
+                currentRange.Duration > maxDuration)
+            {
+                continue;
+            }
+
+            // Regex.IsMatch() is used here in order to allow the runtime to cache the compiled regex
+            // between function invocations.
+            var match = Regex.IsMatch(
+                current.Name,
+                expression,
+                RegexOptions.None,
+                TimeSpan.FromSeconds(1));
+
+            if (!match)
+            {
+                continue;
+            }
+
+            matchingChapter = new Intro(id, currentRange);
+            break;
+        }
+
+        return matchingChapter;
+    }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs
index 04f9da0..f226835 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChromaprintAnalyzer.cs
@@ -82,7 +82,6 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
             }
             catch (FingerprintException ex)
             {
-                // TODO: FIXME: move to debug level?
                 _logger.LogWarning("Caught fingerprint error: {Ex}", ex);
 
                 // Fallback to an empty fingerprint on any error
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
index f4789db..463d5b6 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
@@ -73,15 +73,27 @@ public PluginConfiguration()
     public int MaximumIntroDuration { get; set; } = 120;
 
     /// <summary>
-    /// Gets or sets the upper limit (in minutes) on the length of each episode's audio track that will be analyzed when searching for ending credits.
+    /// Gets or sets the upper limit (in seconds) on the length of each episode's audio track that will be analyzed when searching for ending credits.
     /// </summary>
-    public int MaximumEpisodeCreditsDuration { get; set; } = 4;
+    public int MaximumEpisodeCreditsDuration { get; set; } = 240;
 
     /// <summary>
     /// Gets or sets the minimum percentage of a frame that must consist of black pixels before it is considered a black frame.
     /// </summary>
     public int BlackFrameMinimumPercentage { get; set; } = 85;
 
+    /// <summary>
+    /// Gets or sets the regular expression used to detect introduction chapters.
+    /// </summary>
+    public string ChapterAnalyzerIntroductionPattern { get; set; } =
+        @"(^|\s)(Intro|Introduction|OP|Opening)(\s|$)";
+
+    /// <summary>
+    /// Gets or sets the regular expression used to detect ending credit chapters.
+    /// </summary>
+    public string ChapterAnalyzerEndCreditsPattern { get; set; } =
+        @"(^|\s)(Credits?|Ending)(\s|$)";
+
     // ===== Playback settings =====
 
     /// <summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
index d6c97f6..b4631b7 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
@@ -73,18 +73,24 @@ public ActionResult ResetIntroTimestamps()
     }
 
     /// <summary>
-    /// Get all introductions. Only used by the end to end testing script.
+    /// Get all introductions or credits. Only used by the end to end testing script.
     /// </summary>
-    /// <response code="200">All introductions have been returned.</response>
+    /// <param name="mode">Mode.</param>
+    /// <response code="200">All timestamps have been returned.</response>
     /// <returns>List of IntroWithMetadata objects.</returns>
     [Authorize(Policy = "RequiresElevation")]
     [HttpGet("Intros/All")]
-    public ActionResult<List<IntroWithMetadata>> GetAllIntros()
+    public ActionResult<List<IntroWithMetadata>> GetAllTimestamps(
+        [FromQuery] AnalysisMode mode = AnalysisMode.Introduction)
     {
         List<IntroWithMetadata> intros = new();
 
+        var timestamps = mode == AnalysisMode.Introduction ?
+            Plugin.Instance!.Intros :
+            Plugin.Instance!.Credits;
+
         // Get metadata for all intros
-        foreach (var intro in Plugin.Instance!.Intros)
+        foreach (var intro in timestamps)
         {
             // Get the details of the item from Jellyfin
             var rawItem = Plugin.Instance!.GetItem(intro.Key);
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
index 84ea81c..be89666 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Plugin.cs
@@ -8,6 +8,8 @@
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Plugins;
 using MediaBrowser.Model.Serialization;
 using Microsoft.Extensions.Logging;
@@ -23,9 +25,10 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     private readonly object _introsLock = new();
     private IXmlSerializer _xmlSerializer;
     private ILibraryManager _libraryManager;
+    private IItemRepository _itemRepository;
     private ILogger<Plugin> _logger;
     private string _introPath;
-    private string _creditsPath;  // TODO: FIXME: remove this
+    private string _creditsPath;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Plugin"/> class.
@@ -34,12 +37,14 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     /// <param name="xmlSerializer">Instance of the <see cref="IXmlSerializer"/> interface.</param>
     /// <param name="serverConfiguration">Server configuration manager.</param>
     /// <param name="libraryManager">Library manager.</param>
+    /// <param name="itemRepository">Item repository.</param>
     /// <param name="logger">Logger.</param>
     public Plugin(
         IApplicationPaths applicationPaths,
         IXmlSerializer xmlSerializer,
         IServerConfigurationManager serverConfiguration,
         ILibraryManager libraryManager,
+        IItemRepository itemRepository,
         ILogger<Plugin> logger)
         : base(applicationPaths, xmlSerializer)
     {
@@ -47,14 +52,13 @@ public Plugin(
 
         _xmlSerializer = xmlSerializer;
         _libraryManager = libraryManager;
+        _itemRepository = itemRepository;
         _logger = logger;
 
         FingerprintCachePath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "cache");
         FFmpegPath = serverConfiguration.GetEncodingOptions().EncoderAppPathDisplay;
         _introPath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "intros.xml");
-
-        // TODO: FIXME: remove this
-        _creditsPath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "credits.csv");
+        _creditsPath = Path.Join(applicationPaths.PluginConfigurationsPath, "intros", "credits.xml");
 
         // Create the base & cache directories (if needed).
         if (!Directory.Exists(FingerprintCachePath))
@@ -73,12 +77,6 @@ public Plugin(
         {
             _logger.LogWarning("Unable to load introduction timestamps: {Exception}", ex);
         }
-
-        // TODO: FIXME: remove this
-        if (File.Exists(_creditsPath))
-        {
-            File.Delete(_creditsPath);
-        }
     }
 
     /// <summary>
@@ -91,6 +89,11 @@ public Plugin(
     /// </summary>
     public Dictionary<Guid, Intro> Intros { get; } = new();
 
+    /// <summary>
+    /// Gets all discovered ending credits.
+    /// </summary>
+    public Dictionary<Guid, Intro> Credits { get; } = new();
+
     /// <summary>
     /// Gets the most recent media item queue.
     /// </summary>
@@ -131,12 +134,23 @@ public void SaveTimestamps()
         {
             var introList = new List<Intro>();
 
+            // Serialize intros
             foreach (var intro in Plugin.Instance!.Intros)
             {
                 introList.Add(intro.Value);
             }
 
             _xmlSerializer.SerializeToFile(introList, _introPath);
+
+            // Serialize credits
+            introList.Clear();
+
+            foreach (var intro in Plugin.Instance!.Credits)
+            {
+                introList.Add(intro.Value);
+            }
+
+            _xmlSerializer.SerializeToFile(introList, _creditsPath);
         }
     }
 
@@ -145,17 +159,29 @@ public void SaveTimestamps()
     /// </summary>
     public void RestoreTimestamps()
     {
-        if (!File.Exists(_introPath))
+        if (File.Exists(_introPath))
         {
-            return;
-        }
+            // Since dictionaries can't be easily serialized, analysis results are stored on disk as a list.
+            var introList = (List<Intro>)_xmlSerializer.DeserializeFromFile(
+                typeof(List<Intro>),
+                _introPath);
 
-        // Since dictionaries can't be easily serialized, analysis results are stored on disk as a list.
-        var introList = (List<Intro>)_xmlSerializer.DeserializeFromFile(typeof(List<Intro>), _introPath);
+            foreach (var intro in introList)
+            {
+                Plugin.Instance!.Intros[intro.EpisodeId] = intro;
+            }
+        }
 
-        foreach (var intro in introList)
+        if (File.Exists(_creditsPath))
         {
-            Plugin.Instance!.Intros[intro.EpisodeId] = intro;
+            var creditList = (List<Intro>)_xmlSerializer.DeserializeFromFile(
+                typeof(List<Intro>),
+                _creditsPath);
+
+            foreach (var credit in creditList)
+            {
+                Plugin.Instance!.Credits[credit.EpisodeId] = credit;
+            }
         }
     }
 
@@ -174,52 +200,33 @@ internal string GetItemPath(Guid id)
         return GetItem(id).Path;
     }
 
-    internal void UpdateTimestamps(Dictionary<Guid, Intro> newIntros, AnalysisMode mode)
+    /// <summary>
+    /// Gets all chapters for this item.
+    /// </summary>
+    /// <param name="id">Item id.</param>
+    /// <returns>List of chapters.</returns>
+    internal List<ChapterInfo> GetChapters(Guid id)
     {
-        switch (mode)
+        return _itemRepository.GetChapters(GetItem(id));
+    }
+
+    internal void UpdateTimestamps(Dictionary<Guid, Intro> newTimestamps, AnalysisMode mode)
+    {
+        lock (_introsLock)
         {
-            case AnalysisMode.Introduction:
-                lock (_introsLock)
+            foreach (var intro in newTimestamps)
+            {
+                if (mode == AnalysisMode.Introduction)
                 {
-                    foreach (var intro in newIntros)
-                    {
-                        Plugin.Instance!.Intros[intro.Key] = intro.Value;
-                    }
-
-                    Plugin.Instance!.SaveTimestamps();
+                    Plugin.Instance!.Intros[intro.Key] = intro.Value;
                 }
-
-                break;
-
-            case AnalysisMode.Credits:
-                // TODO: FIXME: implement properly
-
-                lock (_introsLock)
+                else if (mode == AnalysisMode.Credits)
                 {
-                    foreach (var credit in newIntros)
-                    {
-                        var item = GetItem(credit.Value.EpisodeId) as Episode;
-                        if (item is null)
-                        {
-                            continue;
-                        }
-
-                        // Format: series, season number, episode number, title, start, end
-                        var contents = string.Format(
-                            System.Globalization.CultureInfo.InvariantCulture,
-                            "{0},{1},{2},{3},{4},{5}\n",
-                            item.SeriesName.Replace(",", string.Empty, StringComparison.Ordinal),
-                            item.AiredSeasonNumber ?? 0,
-                            item.IndexNumber ?? 0,
-                            item.Name.Replace(",", string.Empty, StringComparison.Ordinal),
-                            Math.Round(credit.Value.IntroStart, 2),
-                            Math.Round(credit.Value.IntroEnd, 2));
-
-                        File.AppendAllText(_creditsPath, contents);
-                    }
+                    Plugin.Instance!.Credits[intro.Key] = intro.Value;
                 }
+            }
 
-                break;
+            Plugin.Instance!.SaveTimestamps();
         }
     }
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index 92f9bbc..4a9fd9e 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -98,9 +98,6 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
         };
 
-        // TODO: FIXME: if the queue is modified while the task is running, the task will fail.
-        // clone the queue before running the task to prevent this.
-
         // Analyze all episodes in the queue using the degrees of parallelism the user specified.
         Parallel.ForEach(queue, options, (season) =>
         {
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 5b232b8..240feb7 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -252,6 +252,10 @@ private int AnalyzeSeason(
             first.SeriesName,
             first.SeasonNumber);
 
+        // Chapter analyzer
+        var chapter = new ChapterAnalyzer(_loggerFactory.CreateLogger<ChapterAnalyzer>());
+        chapter.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);
+
         // Analyze the season with Chromaprint
         var chromaprint = new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>());
         chromaprint.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);

From bfb821f31119edd525312de18e57eb61df686533 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Thu, 24 Nov 2022 00:44:33 -0600
Subject: [PATCH 11/22] Update CHANGELOG.md

---
 CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd38246..821a8f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,11 @@
 
 ## v0.1.8.0 (no eta)
 * New features
+  * Support adding skip intro button to web interface without using a fork
+  * Add localization support for the skip intro button and the automatic skip notification message
   * Detect ending credits in television episodes
+  * Add support for using chapter names to locate introductions and ending credits
+  * Add support for using black frames to locate ending credits
 * Internal changes
   * Move Chromaprint analysis code out of the episode analysis task
   * Add support for multiple analysis techinques

From 7439720b3a94d72fae998f152d53cd88937183d7 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Fri, 25 Nov 2022 00:37:30 -0600
Subject: [PATCH 12/22] Add chaining and logs to chapter analyzer

---
 .../TestChapterAnalyzer.cs                    |  2 +-
 .../Analyzers/ChapterAnalyzer.cs              | 44 ++++++++++++-------
 .../ScheduledTasks/DetectIntroductionsTask.cs |  2 +-
 3 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
index e1da0ab..96feb8e 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestChapterAnalyzer.cs
@@ -51,7 +51,7 @@ public void TestEndCreditsExpression(string chapterName)
             config.ChapterAnalyzerIntroductionPattern :
             config.ChapterAnalyzerEndCreditsPattern;
 
-        return analyzer.FindMatchingChapter(Guid.Empty, 2000, chapters, expression, mode);
+        return analyzer.FindMatchingChapter(new() { Duration = 2000 }, chapters, expression, mode);
     }
 
     private Collection<ChapterInfo> CreateChapters(string name, AnalysisMode mode)
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
index 86efd53..73ec9aa 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
@@ -3,6 +3,7 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Globalization;
 using System.Text.RegularExpressions;
 using System.Threading;
 using Microsoft.Extensions.Logging;
@@ -30,7 +31,9 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         AnalysisMode mode,
         CancellationToken cancellationToken)
     {
+        var unsuccessful = new List<QueuedEpisode>();
         var skippableRanges = new Dictionary<Guid, Intro>();
+
         var expression = mode == AnalysisMode.Introduction ?
             Plugin.Instance!.Configuration.ChapterAnalyzerIntroductionPattern :
             Plugin.Instance!.Configuration.ChapterAnalyzerEndCreditsPattern;
@@ -43,14 +46,14 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
             }
 
             var skipRange = FindMatchingChapter(
-                episode.EpisodeId,
-                episode.Duration,
+                episode,
                 new(Plugin.Instance!.GetChapters(episode.EpisodeId)),
                 expression,
                 mode);
 
             if (skipRange is null)
             {
+                unsuccessful.Add(episode);
                 continue;
             }
 
@@ -59,22 +62,20 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
 
         Plugin.Instance!.UpdateTimestamps(skippableRanges, mode);
 
-        return analysisQueue;
+        return unsuccessful.AsReadOnly();
     }
 
     /// <summary>
     /// Searches a list of chapter names for one that matches the provided regular expression.
     /// Only public to allow for unit testing.
     /// </summary>
-    /// <param name="id">Item id.</param>
-    /// <param name="duration">Duration of media file in seconds.</param>
+    /// <param name="episode">Episode.</param>
     /// <param name="chapters">Media item chapters.</param>
     /// <param name="expression">Regular expression pattern.</param>
     /// <param name="mode">Analysis mode.</param>
     /// <returns>Intro object containing skippable time range, or null if no chapter matched.</returns>
     public Intro? FindMatchingChapter(
-        Guid id,
-        int duration,
+        QueuedEpisode episode,
         Collection<ChapterInfo> chapters,
         string expression,
         AnalysisMode mode)
@@ -82,6 +83,7 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         Intro? matchingChapter = null;
 
         var config = Plugin.Instance?.Configuration ?? new Configuration.PluginConfiguration();
+
         var minDuration = config.MinimumIntroDuration;
         int maxDuration = mode == AnalysisMode.Introduction ?
             config.MaximumIntroDuration :
@@ -91,28 +93,38 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         {
             // Since the ending credits chapter may be the last chapter in the file, append a virtual
             // chapter at the very end of the file.
-            chapters.Add(new ChapterInfo()
+            chapters.Add(new()
             {
-                StartPositionTicks = TimeSpan.FromSeconds(duration).Ticks
+                StartPositionTicks = TimeSpan.FromSeconds(episode.Duration).Ticks
             });
         }
 
         // Check all chapters
         for (int i = 0; i < chapters.Count - 1; i++)
         {
-            // Calculate chapter position and duration
             var current = chapters[i];
             var next = chapters[i + 1];
 
+            if (string.IsNullOrWhiteSpace(current.Name))
+            {
+                continue;
+            }
+
             var currentRange = new TimeRange(
                 TimeSpan.FromTicks(current.StartPositionTicks).TotalSeconds,
                 TimeSpan.FromTicks(next.StartPositionTicks).TotalSeconds);
 
-            // Skip chapters with that don't have a name or are too short/long
-            if (string.IsNullOrEmpty(current.Name) ||
-                currentRange.Duration < minDuration ||
-                currentRange.Duration > maxDuration)
+            var baseMessage = string.Format(
+                CultureInfo.InvariantCulture,
+                "{0}: Chapter \"{1}\" ({2} - {3})",
+                episode.Path,
+                current.Name,
+                currentRange.Start,
+                currentRange.End);
+
+            if (currentRange.Duration < minDuration || currentRange.Duration > maxDuration)
             {
+                _logger.LogTrace("{Base}: ignoring (invalid duration)", baseMessage);
                 continue;
             }
 
@@ -126,10 +138,12 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
 
             if (!match)
             {
+                _logger.LogTrace("{Base}: ignoring (does not match regular expression)", baseMessage);
                 continue;
             }
 
-            matchingChapter = new Intro(id, currentRange);
+            matchingChapter = new(episode.EpisodeId, currentRange);
+            _logger.LogTrace("{Base}: okay", baseMessage);
             break;
         }
 
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 240feb7..83df267 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -254,7 +254,7 @@ private int AnalyzeSeason(
 
         // Chapter analyzer
         var chapter = new ChapterAnalyzer(_loggerFactory.CreateLogger<ChapterAnalyzer>());
-        chapter.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);
+        episodes = chapter.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);
 
         // Analyze the season with Chromaprint
         var chromaprint = new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>());

From ae16603aeedddf1d586660ce0540d1fe753b7aef Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Fri, 25 Nov 2022 00:40:02 -0600
Subject: [PATCH 13/22] Support returning credit timestamps

---
 .../Controllers/SkipIntroController.cs        | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
index b4631b7..85b9804 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
@@ -26,14 +26,17 @@ public SkipIntroController()
     /// Returns the timestamps of the introduction in a television episode. Responses are in API version 1 format.
     /// </summary>
     /// <param name="id">ID of the episode. Required.</param>
+    /// <param name="mode">Timestamps to return. Optional. Defaults to Introduction for backwards compatibility.</param>
     /// <response code="200">Episode contains an intro.</response>
     /// <response code="404">Failed to find an intro in the provided episode.</response>
     /// <returns>Detected intro.</returns>
     [HttpGet("Episode/{id}/IntroTimestamps")]
     [HttpGet("Episode/{id}/IntroTimestamps/v1")]
-    public ActionResult<Intro> GetIntroTimestamps([FromRoute] Guid id)
+    public ActionResult<Intro> GetIntroTimestamps(
+        [FromRoute] Guid id,
+        [FromQuery] AnalysisMode mode = AnalysisMode.Introduction)
     {
-        var intro = GetIntro(id);
+        var intro = GetIntro(id, mode);
 
         if (intro is null || !intro.Valid)
         {
@@ -49,13 +52,25 @@ public ActionResult<Intro> GetIntroTimestamps([FromRoute] Guid id)
         return intro;
     }
 
-    /// <summary>Lookup and return the intro timestamps for the provided item.</summary>
+    /// <summary>Lookup and return the skippable timestamps for the provided item.</summary>
     /// <param name="id">Unique identifier of this episode.</param>
+    /// <param name="mode">Mode.</param>
     /// <returns>Intro object if the provided item has an intro, null otherwise.</returns>
-    private Intro? GetIntro(Guid id)
+    private Intro? GetIntro(Guid id, AnalysisMode mode)
     {
-        // Returns a copy to avoid mutating the original Intro object stored in the dictionary.
-        return Plugin.Instance!.Intros.TryGetValue(id, out var intro) ? new Intro(intro) : null;
+        try
+        {
+            var timestamp = mode == AnalysisMode.Introduction ?
+                Plugin.Instance!.Intros[id] :
+                Plugin.Instance!.Credits[id];
+
+            // A copy is returned to avoid mutating the original Intro object stored in the dictionary.
+            return new(timestamp);
+        }
+        catch (KeyNotFoundException)
+        {
+            return null;
+        }
     }
 
     /// <summary>

From 3e2dc377b7f791dd4e90b476d0f836670539aad6 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Fri, 25 Nov 2022 00:41:48 -0600
Subject: [PATCH 14/22] Add new task ID

---
 .../e2e_tests/verifier/report_generator.go             | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
index 708f864..2c4fb3b 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/e2e_tests/verifier/report_generator.go
@@ -113,11 +113,13 @@ func runAnalysisAndWait(hostAddress, apiKey string, pollInterval time.Duration)
 	SendRequest("POST", hostAddress+"/Intros/EraseTimestamps", apiKey)
 	fmt.Println()
 
-	// The task ID changed with v0.1.7.
-	// Old task ID: 8863329048cc357f7dfebf080f2fe204
-	// New task ID: 6adda26c5261c40e8fa4a7e7df568be2
+	var taskIds = []string{
+		"f64d8ad58e3d7b98548e1a07697eb100", // v0.1.8
+		"8863329048cc357f7dfebf080f2fe204",
+		"6adda26c5261c40e8fa4a7e7df568be2"}
+
 	fmt.Println("[+] Starting analysis task")
-	for _, id := range []string{"8863329048cc357f7dfebf080f2fe204", "6adda26c5261c40e8fa4a7e7df568be2"} {
+	for _, id := range taskIds {
 		body := SendRequest("POST", hostAddress+"/ScheduledTasks/Running/"+id, apiKey)
 		fmt.Println()
 

From cb234bedd3f137c82aa6c3ea0c225f04b502b3d6 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Sat, 26 Nov 2022 02:28:40 -0600
Subject: [PATCH 15/22] Update black frame and chapter analyzer

---
 .../Analyzers/BlackFrameAnalyzer.cs                  | 12 +++++++++---
 .../Analyzers/ChapterAnalyzer.cs                     |  8 +++++---
 .../Data/QueuedEpisode.cs                            |  4 ++--
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
index 1c28c5f..ba2ee30 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
@@ -76,8 +76,10 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
     /// <returns>Credits timestamp.</returns>
     public Intro? AnalyzeMediaFile(QueuedEpisode episode, AnalysisMode mode, int minimum)
     {
-        // Start by analyzing the last four minutes of the file.
-        var start = TimeSpan.FromMinutes(4);
+        var config = Plugin.Instance?.Configuration ?? new Configuration.PluginConfiguration();
+
+        // Start by analyzing the last N minutes of the file.
+        var start = TimeSpan.FromSeconds(config.MaximumEpisodeCreditsDuration);
         var end = TimeSpan.Zero;
         var firstFrameTime = 0.0;
 
@@ -100,7 +102,11 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
                 tr.End);
 
             var frames = FFmpegWrapper.DetectBlackFrames(episode, tr, minimum);
-            _logger.LogTrace("{Episode}, black frames: {Count}", episode.Name, frames.Length);
+            _logger.LogTrace(
+                "{Episode} at {Start} has {Count} black frames",
+                episode.Name,
+                tr.Start,
+                frames.Length);
 
             if (frames.Length == 0)
             {
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
index 73ec9aa..5accbb4 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
@@ -4,6 +4,7 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
+using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading;
 using Microsoft.Extensions.Logging;
@@ -31,7 +32,6 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
         AnalysisMode mode,
         CancellationToken cancellationToken)
     {
-        var unsuccessful = new List<QueuedEpisode>();
         var skippableRanges = new Dictionary<Guid, Intro>();
 
         var expression = mode == AnalysisMode.Introduction ?
@@ -53,7 +53,6 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
 
             if (skipRange is null)
             {
-                unsuccessful.Add(episode);
                 continue;
             }
 
@@ -62,7 +61,10 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
 
         Plugin.Instance!.UpdateTimestamps(skippableRanges, mode);
 
-        return unsuccessful.AsReadOnly();
+        return analysisQueue
+            .Where(x => !skippableRanges.ContainsKey(x.EpisodeId))
+            .ToList()
+            .AsReadOnly();
     }
 
     /// <summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
index 0964258..bb65789 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Data/QueuedEpisode.cs
@@ -33,12 +33,12 @@ public class QueuedEpisode
     public string Name { get; set; } = string.Empty;
 
     /// <summary>
-    /// Gets or sets the timestamp (in seconds) to stop searching for an introduction.
+    /// Gets or sets the timestamp (in seconds) to stop searching for an introduction at.
     /// </summary>
     public int IntroFingerprintEnd { get; set; }
 
     /// <summary>
-    /// Gets or sets the timestamp (in seconds) to start looking for end credits.
+    /// Gets or sets the timestamp (in seconds) to start looking for end credits at.
     /// </summary>
     public int CreditsFingerprintStart { get; set; }
 

From 94bd2a059e3ba2e908abb98c67165e528bebabd7 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 29 Nov 2022 02:29:27 -0600
Subject: [PATCH 16/22] Use chromaprint analyzer when detecting credits

---
 ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs           | 2 +-
 .../ScheduledTasks/DetectCreditsTask.cs                         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
index 4f3308f..dfc5639 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
@@ -205,7 +205,7 @@ private void QueueEpisode(Episode episode)
         _queuedEpisodes.TryAdd(episode.SeasonId, new List<QueuedEpisode>());
 
         // Queue the episode for analysis
-        var maxCreditsDuration = Plugin.Instance!.Configuration.MaximumEpisodeCreditsDuration * 60;
+        var maxCreditsDuration = Plugin.Instance!.Configuration.MaximumEpisodeCreditsDuration;
         _queuedEpisodes[episode.SeasonId].Add(new QueuedEpisode()
         {
             SeriesName = episode.SeriesName,
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index 4a9fd9e..74ef0c0 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -165,7 +165,7 @@ private void AnalyzeSeason(
         // Analyze with Chromaprint first and fall back to the black frame detector
         var analyzers = new IMediaFileAnalyzer[]
         {
-            // TODO: FIXME: new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>()),
+            new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>()),
             new BlackFrameAnalyzer(_loggerFactory.CreateLogger<BlackFrameAnalyzer>())
         };
 

From 16251f0735c37e596debc8ff1b3eb4f6d5dbc889 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 29 Nov 2022 02:31:24 -0600
Subject: [PATCH 17/22] Support erasing times for intros and end credits

---
 .../Configuration/configPage.html             | 61 +++++++++++++------
 .../Controllers/SkipIntroController.cs        | 13 +++-
 2 files changed, 53 insertions(+), 21 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/configPage.html b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/configPage.html
index 401bd92..ad4fc31 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/configPage.html
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/configPage.html
@@ -201,7 +201,8 @@
                             </label>
 
                             <div class="fieldDescription">
-                                If checked, intros will be automatically skipped. If you access Jellyfin through a reverse proxy, it must be configured to proxy web
+                                If checked, intros will be automatically skipped. If you access Jellyfin through a
+                                reverse proxy, it must be configured to proxy web
                                 sockets.<br />
                             </div>
                         </div>
@@ -253,10 +254,6 @@
                             <span>Save</span>
                         </button>
                         <br />
-
-                        <button id="btnEraseTimestamps" is="emby-button" class="raised block emby-button">
-                            <span>Erase introduction timestamps</span>
-                        </button>
                     </div>
                 </form>
             </div>
@@ -302,7 +299,17 @@ <h3 style="margin:0">Introduction timestamp editor</h3>
                     <button id="btnEraseSeasonTimestamps" type="button">
                         Erase all timestamps for this season
                     </button>
+                    <hr />
                 </div>
+
+                <button id="btnEraseIntroTimestamps">
+                    Erase all introduction timestamps (globally)
+                </button>
+                <br />
+
+                <button id="btnEraseCreditTimestamps">
+                    Erase all end credits timestamps (globally)
+                </button>
                 <br />
                 <br />
 
@@ -376,7 +383,8 @@ <h3>Fingerprint Visualizer</h3>
             // settings elements
             var visualizer = document.querySelector("details#visualizer");
             var support = document.querySelector("details#support");
-            var btnEraseTimestamps = document.querySelector("button#btnEraseTimestamps");
+            var btnEraseIntroTimestamps = document.querySelector("button#btnEraseIntroTimestamps");
+            var btnEraseCreditTimestamps = document.querySelector("button#btnEraseCreditTimestamps");
 
             // all plugin configuration fields that can be get or set with .value (i.e. strings or numbers).
             var configurationFields = [
@@ -662,6 +670,28 @@ <h3>Fingerprint Visualizer</h3>
                 return new Date(seconds * 1000).toISOString().substr(14, 5);
             }
 
+            // erase all intro/credits timestamps
+            function eraseTimestamps(mode) {
+                const lower = mode.toLocaleLowerCase();
+                const title = "Confirm timestamp erasure";
+                const body = "Are you sure you want to erase all previously discovered " +
+                    mode.toLocaleLowerCase() +
+                    " timestamps?";
+
+                Dashboard.confirm(
+                    body,
+                    title,
+                    (result) => {
+                        if (!result) {
+                            return;
+                        }
+
+                        fetchWithAuth("Intros/EraseTimestamps?mode=" + mode, "POST", null);
+
+                        Dashboard.alert(mode + " timestamps erased");
+                    });
+            }
+
             document.querySelector('#TemplateConfigPage')
                 .addEventListener('pageshow', function () {
                     Dashboard.showLoadingMsg();
@@ -707,19 +737,12 @@ <h3>Fingerprint Visualizer</h3>
             selectSeason.addEventListener("change", seasonChanged);
             selectEpisode1.addEventListener("change", episodeChanged);
             selectEpisode2.addEventListener("change", episodeChanged);
-            btnEraseTimestamps.addEventListener("click", (e) => {
-                Dashboard.confirm(
-                    "Are you sure you want to erase all previously discovered introduction timestamps?",
-                    "Confirm timestamp erasure",
-                    (result) => {
-                        if (!result) {
-                            return;
-                        }
-
-                        // reset all intro timestamps on the server so a new fingerprint comparison algorithm can be tested
-                        fetchWithAuth("Intros/EraseTimestamps", "POST", null);
-                    });
-
+            btnEraseIntroTimestamps.addEventListener("click", (e) => {
+                eraseTimestamps("Introduction");
+                e.preventDefault();
+            });
+            btnEraseCreditTimestamps.addEventListener("click", (e) => {
+                eraseTimestamps("Credits");
                 e.preventDefault();
             });
             btnSeasonEraseTimestamps.addEventListener("click", () => {
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
index 85b9804..3f12bb9 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Controllers/SkipIntroController.cs
@@ -76,13 +76,22 @@ public ActionResult<Intro> GetIntroTimestamps(
     /// <summary>
     /// Erases all previously discovered introduction timestamps.
     /// </summary>
+    /// <param name="mode">Mode.</param>
     /// <response code="204">Operation successful.</response>
     /// <returns>No content.</returns>
     [Authorize(Policy = "RequiresElevation")]
     [HttpPost("Intros/EraseTimestamps")]
-    public ActionResult ResetIntroTimestamps()
+    public ActionResult ResetIntroTimestamps([FromQuery] AnalysisMode mode)
     {
-        Plugin.Instance!.Intros.Clear();
+        if (mode == AnalysisMode.Introduction)
+        {
+            Plugin.Instance!.Intros.Clear();
+        }
+        else if (mode == AnalysisMode.Credits)
+        {
+            Plugin.Instance!.Credits.Clear();
+        }
+
         Plugin.Instance!.SaveTimestamps();
         return NoContent();
     }

From 0afc4cab41d2e6737bb1ddb83643417753f1d2f2 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 29 Nov 2022 20:11:22 -0600
Subject: [PATCH 18/22] Add minimum end credit duration

---
 .../TestBlackFrames.cs                                       | 4 +++-
 .../Analyzers/BlackFrameAnalyzer.cs                          | 2 +-
 .../Configuration/PluginConfiguration.cs                     | 5 +++++
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
index bdd34e5..16caf27 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper.Tests/TestBlackFrames.cs
@@ -30,6 +30,8 @@ public void TestBlackFrameDetection()
     [FactSkipFFmpegTests]
     public void TestEndCreditDetection()
     {
+        var range = 1;
+
         var analyzer = CreateBlackFrameAnalyzer();
 
         var episode = queueFile("credits.mp4");
@@ -37,7 +39,7 @@ public void TestEndCreditDetection()
 
         var result = analyzer.AnalyzeMediaFile(episode, AnalysisMode.Credits, 85);
         Assert.NotNull(result);
-        Assert.Equal(300, result.IntroStart);
+        Assert.InRange(result.IntroStart, 300 - range, 300 + range);
     }
 
     private QueuedEpisode queueFile(string path)
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
index ba2ee30..89a4018 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/BlackFrameAnalyzer.cs
@@ -80,7 +80,7 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
 
         // Start by analyzing the last N minutes of the file.
         var start = TimeSpan.FromSeconds(config.MaximumEpisodeCreditsDuration);
-        var end = TimeSpan.Zero;
+        var end = TimeSpan.FromSeconds(config.MinimumCreditsDuration);
         var firstFrameTime = 0.0;
 
         // Continue bisecting the end of the file until the range that contains the first black
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
index 463d5b6..d6b38bb 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Configuration/PluginConfiguration.cs
@@ -72,6 +72,11 @@ public PluginConfiguration()
     /// </summary>
     public int MaximumIntroDuration { get; set; } = 120;
 
+    /// <summary>
+    /// Gets or sets the minimum length of similar audio that will be considered ending credits.
+    /// </summary>
+    public int MinimumCreditsDuration { get; set; } = 15;
+
     /// <summary>
     /// Gets or sets the upper limit (in seconds) on the length of each episode's audio track that will be analyzed when searching for ending credits.
     /// </summary>

From 4bb978639c26b15235bdfe3f11a54b24e1293c76 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Tue, 29 Nov 2022 20:31:41 -0600
Subject: [PATCH 19/22] Don't run chapter analyzer with an empty regex

---
 .../Analyzers/ChapterAnalyzer.cs                             | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
index 5accbb4..558c0e9 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Analyzers/ChapterAnalyzer.cs
@@ -38,6 +38,11 @@ public ReadOnlyCollection<QueuedEpisode> AnalyzeMediaFiles(
             Plugin.Instance!.Configuration.ChapterAnalyzerIntroductionPattern :
             Plugin.Instance!.Configuration.ChapterAnalyzerEndCreditsPattern;
 
+        if (string.IsNullOrWhiteSpace(expression))
+        {
+            return analysisQueue;
+        }
+
         foreach (var episode in analysisQueue)
         {
             if (cancellationToken.IsCancellationRequested)

From 1966357e29f8f7102b92a86faab7dee41b0c9953 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Mon, 5 Dec 2022 22:35:01 -0600
Subject: [PATCH 20/22] Resolve all remaining FIXMEs with credit detection

---
 .../Entrypoint.cs                             |  2 +-
 .../QueueManager.cs                           | 52 ++++++++++++++++-
 .../ScheduledTasks/DetectCreditsTask.cs       | 14 ++---
 .../ScheduledTasks/DetectIntroductionsTask.cs | 57 +++----------------
 4 files changed, 64 insertions(+), 61 deletions(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs b/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
index a7a176a..a2c1877 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/Entrypoint.cs
@@ -60,7 +60,7 @@ public Task RunAsync()
             // Enqueue all episodes at startup to ensure any FFmpeg errors appear as early as possible
             _logger.LogInformation("Running startup enqueue");
             var queueManager = new QueueManager(_loggerFactory.CreateLogger<QueueManager>(), _libraryManager);
-            queueManager.EnqueueAllEpisodes();
+            queueManager.GetMediaItems();
         }
         catch (Exception ex)
         {
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
index dfc5639..bfe2105 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/QueueManager.cs
@@ -3,6 +3,7 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.IO;
 using System.Linq;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Entities;
@@ -37,10 +38,10 @@ public QueueManager(ILogger<QueueManager> logger, ILibraryManager libraryManager
     }
 
     /// <summary>
-    /// Iterates through all libraries on the server and queues all episodes for analysis.
+    /// Gets all media items on the server.
     /// </summary>
     /// <returns>Queued media items.</returns>
-    public ReadOnlyDictionary<Guid, List<QueuedEpisode>> EnqueueAllEpisodes()
+    public ReadOnlyDictionary<Guid, List<QueuedEpisode>> GetMediaItems()
     {
         // Assert that ffmpeg with chromaprint is installed
         if (!FFmpegWrapper.CheckFFmpegVersion())
@@ -220,4 +221,51 @@ private void QueueEpisode(Episode episode)
 
         Plugin.Instance!.TotalQueued++;
     }
+
+    /// <summary>
+    /// Verify that a collection of queued media items still exist in Jellyfin and in storage.
+    /// This is done to ensure that we don't analyze items that were deleted between the call to GetMediaItems() and popping them from the queue.
+    /// </summary>
+    /// <param name="candidates">Queued media items.</param>
+    /// <param name="mode">Analysis mode.</param>
+    /// <returns>Media items that have been verified to exist in Jellyfin and in storage.</returns>
+    public (ReadOnlyCollection<QueuedEpisode> VerifiedItems, bool AnyUnanalyzed)
+        VerifyQueue(ReadOnlyCollection<QueuedEpisode> candidates, AnalysisMode mode)
+    {
+        var unanalyzed = false;
+        var verified = new List<QueuedEpisode>();
+
+        var timestamps = mode == AnalysisMode.Introduction ?
+                Plugin.Instance!.Intros :
+                Plugin.Instance!.Credits;
+
+        foreach (var candidate in candidates)
+        {
+            try
+            {
+                var path = Plugin.Instance!.GetItemPath(candidate.EpisodeId);
+
+                if (File.Exists(path))
+                {
+                    verified.Add(candidate);
+                }
+
+                if (!timestamps.ContainsKey(candidate.EpisodeId))
+                {
+                    unanalyzed = true;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogDebug(
+                    "Skipping {Mode} analysis of {Name} ({Id}): {Exception}",
+                    mode,
+                    candidate.Name,
+                    candidate.EpisodeId,
+                    ex);
+            }
+        }
+
+        return (verified.AsReadOnly(), unanalyzed);
+    }
 }
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index 74ef0c0..fa05f34 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -9,10 +9,6 @@
 
 namespace ConfusedPolarBear.Plugin.IntroSkipper;
 
-#if !DEBUG
-#error Fix all FIXMEs introduced during initial credit implementation before release
-#endif
-
 /// <summary>
 /// Analyze all television episodes for credits.
 /// </summary>
@@ -84,7 +80,7 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             _loggerFactory.CreateLogger<QueueManager>(),
             _libraryManager);
 
-        var queue = queueManager.EnqueueAllEpisodes();
+        var queue = queueManager.GetMediaItems();
 
         if (queue.Count == 0)
         {
@@ -101,9 +97,11 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
         // Analyze all episodes in the queue using the degrees of parallelism the user specified.
         Parallel.ForEach(queue, options, (season) =>
         {
-            // TODO: FIXME: use VerifyEpisodes
-            var episodes = season.Value.AsReadOnly();
-            if (episodes.Count == 0)
+            var (episodes, unanalyzed) = queueManager.VerifyQueue(
+                season.Value.AsReadOnly(),
+                AnalysisMode.Credits);
+
+            if (episodes.Count == 0 || unanalyzed)
             {
                 return;
             }
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 83df267..23890a0 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -83,7 +83,7 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             _loggerFactory.CreateLogger<QueueManager>(),
             _libraryManager);
 
-        var queue = queueManager.EnqueueAllEpisodes();
+        var queue = queueManager.GetMediaItems();
 
         if (queue.Count == 0)
         {
@@ -100,13 +100,15 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
             MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
         };
 
-        // TODO: if the queue is modified while the task is running, the task will fail.
-        // clone the queue before running the task to prevent this.
-
         // Analyze all episodes in the queue using the degrees of parallelism the user specified.
         Parallel.ForEach(queue, options, (season) =>
         {
-            var (episodes, unanalyzed) = VerifyEpisodes(season.Value.AsReadOnly());
+            // Since the first run of the task can run for multiple hours, ensure that none
+            // of the current media items were deleted from Jellyfin since the task was started.
+            var (episodes, unanalyzed) = queueManager.VerifyQueue(
+                season.Value.AsReadOnly(),
+                AnalysisMode.Introduction);
+
             if (episodes.Count == 0)
             {
                 return;
@@ -178,51 +180,6 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
         return Task.CompletedTask;
     }
 
-    /// <summary>
-    /// Verify that all episodes in a season exist in Jellyfin and as a file in storage.
-    /// TODO: FIXME: move to queue manager.
-    /// </summary>
-    /// <param name="candidates">QueuedEpisodes.</param>
-    /// <returns>Verified QueuedEpisodes and a flag indicating if any episode in this season has not been analyzed yet.</returns>
-    private (
-        ReadOnlyCollection<QueuedEpisode> VerifiedEpisodes,
-        bool AnyUnanalyzed)
-        VerifyEpisodes(ReadOnlyCollection<QueuedEpisode> candidates)
-    {
-        var unanalyzed = false;
-        var verified = new List<QueuedEpisode>();
-
-        foreach (var candidate in candidates)
-        {
-            try
-            {
-                // Verify that the episode exists in Jellyfin and in storage
-                var path = Plugin.Instance!.GetItemPath(candidate.EpisodeId);
-
-                if (File.Exists(path))
-                {
-                    verified.Add(candidate);
-                }
-
-                // Flag this season for analysis if the current episode hasn't been analyzed yet
-                if (!Plugin.Instance.Intros.ContainsKey(candidate.EpisodeId))
-                {
-                    unanalyzed = true;
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogDebug(
-                    "Skipping analysis of {Name} ({Id}): {Exception}",
-                    candidate.Name,
-                    candidate.EpisodeId,
-                    ex);
-            }
-        }
-
-        return (verified.AsReadOnly(), unanalyzed);
-    }
-
     /// <summary>
     /// Fingerprints all episodes in the provided season and stores the timestamps of all introductions.
     /// </summary>

From 431aed58ffa8705de38a919f7804b3e4350ba9c3 Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Thu, 2 Feb 2023 01:20:11 -0600
Subject: [PATCH 21/22] Combine introduction and credits detection code

---
 .../ScheduledTasks/BaseItemAnalyzerTask.cs    | 198 ++++++++++++++++++
 .../ScheduledTasks/DetectCreditsTask.cs       | 136 +-----------
 .../ScheduledTasks/DetectIntroductionsTask.cs | 164 +--------------
 3 files changed, 217 insertions(+), 281 deletions(-)
 create mode 100644 ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs
new file mode 100644
index 0000000..6a8f50e
--- /dev/null
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs
@@ -0,0 +1,198 @@
+namespace ConfusedPolarBear.Plugin.IntroSkipper;
+
+using System;
+using System.Collections.ObjectModel;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+/// <summary>
+/// Common code shared by all media item analyzer tasks.
+/// </summary>
+public class BaseItemAnalyzerTask
+{
+    private readonly AnalysisMode _analysisMode;
+
+    private readonly ILogger _logger;
+
+    private readonly ILoggerFactory _loggerFactory;
+
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BaseItemAnalyzerTask"/> class.
+    /// </summary>
+    /// <param name="mode">Analysis mode.</param>
+    /// <param name="logger">Task logger.</param>
+    /// <param name="loggerFactory">Logger factory.</param>
+    /// <param name="libraryManager">Library manager.</param>
+    public BaseItemAnalyzerTask(
+        AnalysisMode mode,
+        ILogger logger,
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager)
+    {
+        _analysisMode = mode;
+        _logger = logger;
+        _loggerFactory = loggerFactory;
+        _libraryManager = libraryManager;
+
+        if (mode == AnalysisMode.Introduction)
+        {
+            EdlManager.Initialize(_logger);
+        }
+    }
+
+    /// <summary>
+    /// Analyze all media items on the server.
+    /// </summary>
+    /// <param name="progress">Progress.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    public void AnalyzeItems(
+        IProgress<double> progress,
+        CancellationToken cancellationToken)
+    {
+        var queueManager = new QueueManager(
+            _loggerFactory.CreateLogger<QueueManager>(),
+            _libraryManager);
+
+        var queue = queueManager.GetMediaItems();
+
+        var totalQueued = 0;
+        foreach (var kvp in queue)
+        {
+            totalQueued += kvp.Value.Count;
+        }
+
+        if (totalQueued == 0)
+        {
+            throw new FingerprintException(
+                "No episodes to analyze. If you are limiting the list of libraries to analyze, check that all library names have been spelled correctly.");
+        }
+
+        if (this._analysisMode == AnalysisMode.Introduction)
+        {
+            EdlManager.LogConfiguration();
+        }
+
+        var totalProcessed = 0;
+        var options = new ParallelOptions()
+        {
+            MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
+        };
+
+        Parallel.ForEach(queue, options, (season) =>
+        {
+            var writeEdl = false;
+
+            // Since the first run of the task can run for multiple hours, ensure that none
+            // of the current media items were deleted from Jellyfin since the task was started.
+            var (episodes, unanalyzed) = queueManager.VerifyQueue(
+                season.Value.AsReadOnly(),
+                this._analysisMode);
+
+            if (episodes.Count == 0)
+            {
+                return;
+            }
+
+            var first = episodes[0];
+
+            if (!unanalyzed)
+            {
+                _logger.LogDebug(
+                    "All episodes in {Name} season {Season} have already been analyzed",
+                    first.SeriesName,
+                    first.SeasonNumber);
+
+                return;
+            }
+
+            try
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                var analyzed = AnalyzeItems(episodes, cancellationToken);
+                Interlocked.Add(ref totalProcessed, analyzed);
+
+                writeEdl = analyzed > 0 || Plugin.Instance!.Configuration.RegenerateEdlFiles;
+            }
+            catch (FingerprintException ex)
+            {
+                _logger.LogWarning(
+                    "Unable to analyze {Series} season {Season}: unable to fingerprint: {Ex}",
+                    first.SeriesName,
+                    first.SeasonNumber,
+                    ex);
+            }
+
+            if (
+                writeEdl &&
+                Plugin.Instance!.Configuration.EdlAction != EdlAction.None &&
+                _analysisMode == AnalysisMode.Introduction)
+            {
+                EdlManager.UpdateEDLFiles(episodes);
+            }
+
+            progress.Report((totalProcessed * 100) / totalQueued);
+        });
+
+        if (
+            _analysisMode == AnalysisMode.Introduction &&
+            Plugin.Instance!.Configuration.RegenerateEdlFiles)
+        {
+            _logger.LogInformation("Turning EDL file regeneration flag off");
+            Plugin.Instance!.Configuration.RegenerateEdlFiles = false;
+            Plugin.Instance!.SaveConfiguration();
+        }
+    }
+
+    /// <summary>
+    /// Analyze a group of media items for skippable segments.
+    /// </summary>
+    /// <param name="items">Media items to analyze.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Number of items that were successfully analyzed.</returns>
+    private int AnalyzeItems(
+        ReadOnlyCollection<QueuedEpisode> items,
+        CancellationToken cancellationToken)
+    {
+        var totalItems = items.Count;
+
+        // Only analyze specials (season 0) if the user has opted in.
+        var first = items[0];
+        if (first.SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
+        {
+            return 0;
+        }
+
+        _logger.LogInformation(
+            "Analyzing {Count} files from {Name} season {Season}",
+            items.Count,
+            first.SeriesName,
+            first.SeasonNumber);
+
+        var analyzers = new Collection<IMediaFileAnalyzer>();
+
+        analyzers.Add(new ChapterAnalyzer(_loggerFactory.CreateLogger<ChapterAnalyzer>()));
+        analyzers.Add(new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>()));
+
+        if (this._analysisMode == AnalysisMode.Credits)
+        {
+            analyzers.Add(new BlackFrameAnalyzer(_loggerFactory.CreateLogger<BlackFrameAnalyzer>()));
+        }
+
+        // Use each analyzer to find skippable ranges in all media files, removing successfully
+        // analyzed items from the queue.
+        foreach (var analyzer in analyzers)
+        {
+            items = analyzer.AnalyzeMediaFiles(items, this._analysisMode, cancellationToken);
+        }
+
+        return totalItems - items.Count;
+    }
+}
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
index fa05f34..8e3bd9c 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectCreditsTask.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Controller.Library;
@@ -11,14 +10,13 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 
 /// <summary>
 /// Analyze all television episodes for credits.
+/// TODO: analyze all media files.
 /// </summary>
 public class DetectCreditsTask : IScheduledTask
 {
-    private readonly ILogger<DetectCreditsTask> _logger;
-
     private readonly ILoggerFactory _loggerFactory;
 
-    private readonly ILibraryManager? _libraryManager;
+    private readonly ILibraryManager _libraryManager;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="DetectCreditsTask"/> class.
@@ -27,19 +25,10 @@ public class DetectCreditsTask : IScheduledTask
     /// <param name="libraryManager">Library manager.</param>
     public DetectCreditsTask(
         ILoggerFactory loggerFactory,
-        ILibraryManager libraryManager) : this(loggerFactory)
-    {
-        _libraryManager = libraryManager;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="DetectCreditsTask"/> class.
-    /// </summary>
-    /// <param name="loggerFactory">Logger factory.</param>
-    public DetectCreditsTask(ILoggerFactory loggerFactory)
+        ILibraryManager libraryManager)
     {
-        _logger = loggerFactory.CreateLogger<DetectCreditsTask>();
         _loggerFactory = loggerFactory;
+        _libraryManager = libraryManager;
     }
 
     /// <summary>
@@ -72,125 +61,20 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
     {
         if (_libraryManager is null)
         {
-            throw new InvalidOperationException("Library manager must not be null");
+            throw new InvalidOperationException("Library manager was null");
         }
 
-        // Make sure the analysis queue matches what's currently in Jellyfin.
-        var queueManager = new QueueManager(
-            _loggerFactory.CreateLogger<QueueManager>(),
+        var baseAnalyzer = new BaseItemAnalyzerTask(
+            AnalysisMode.Credits,
+            _loggerFactory.CreateLogger<DetectCreditsTask>(),
+            _loggerFactory,
             _libraryManager);
 
-        var queue = queueManager.GetMediaItems();
-
-        if (queue.Count == 0)
-        {
-            throw new FingerprintException(
-                "No episodes to analyze. If you are limiting the list of libraries to analyze, check that all library names have been spelled correctly.");
-        }
-
-        var totalProcessed = 0;
-        var options = new ParallelOptions()
-        {
-            MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
-        };
-
-        // Analyze all episodes in the queue using the degrees of parallelism the user specified.
-        Parallel.ForEach(queue, options, (season) =>
-        {
-            var (episodes, unanalyzed) = queueManager.VerifyQueue(
-                season.Value.AsReadOnly(),
-                AnalysisMode.Credits);
-
-            if (episodes.Count == 0 || unanalyzed)
-            {
-                return;
-            }
-
-            var first = episodes[0];
-
-            try
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                AnalyzeSeason(episodes, cancellationToken);
-                Interlocked.Add(ref totalProcessed, episodes.Count);
-            }
-            catch (FingerprintException ex)
-            {
-                _logger.LogWarning(
-                    "Unable to analyze {Series} season {Season}: unable to fingerprint: {Ex}",
-                    first.SeriesName,
-                    first.SeasonNumber,
-                    ex);
-            }
-            catch (KeyNotFoundException ex)
-            {
-                _logger.LogWarning(
-                    "Unable to analyze {Series} season {Season}: cache miss: {Ex}",
-                    first.SeriesName,
-                    first.SeasonNumber,
-                    ex);
-            }
-
-            var total = Plugin.Instance!.TotalQueued;
-            if (total > 0)
-            {
-                progress.Report((totalProcessed * 100) / total);
-            }
-        });
+        baseAnalyzer.AnalyzeItems(progress, cancellationToken);
 
         return Task.CompletedTask;
     }
 
-    /// <summary>
-    /// Analyzes all episodes in the season for end credits.
-    /// </summary>
-    /// <param name="episodes">Episodes in this season.</param>
-    /// <param name="cancellationToken">Cancellation token provided by the scheduled task.</param>
-    private void AnalyzeSeason(
-        ReadOnlyCollection<QueuedEpisode> episodes,
-        CancellationToken cancellationToken)
-    {
-        // Only analyze specials (season 0) if the user has opted in.
-        if (episodes[0].SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
-        {
-            return;
-        }
-
-        // Analyze with Chromaprint first and fall back to the black frame detector
-        var analyzers = new IMediaFileAnalyzer[]
-        {
-            new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>()),
-            new BlackFrameAnalyzer(_loggerFactory.CreateLogger<BlackFrameAnalyzer>())
-        };
-
-        // Use each analyzer to find credits in all media files, removing successfully analyzed files
-        // from the queue.
-        var remaining = new ReadOnlyCollection<QueuedEpisode>(episodes);
-        foreach (var analyzer in analyzers)
-        {
-            remaining = AnalyzeFiles(remaining, analyzer, cancellationToken);
-        }
-    }
-
-    private ReadOnlyCollection<QueuedEpisode> AnalyzeFiles(
-        ReadOnlyCollection<QueuedEpisode> episodes,
-        IMediaFileAnalyzer analyzer,
-        CancellationToken cancellationToken)
-    {
-        _logger.LogInformation(
-            "Analyzing {Count} episodes from {Name} season {Season} with {Analyzer}",
-            episodes.Count,
-            episodes[0].SeriesName,
-            episodes[0].SeasonNumber,
-            analyzer.GetType().Name);
-
-        return analyzer.AnalyzeMediaFiles(episodes, AnalysisMode.Credits, cancellationToken);
-    }
-
     /// <summary>
     /// Get task triggers.
     /// </summary>
diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
index 23890a0..c0f1609 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/DetectIntroductionsTask.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Controller.Library;
@@ -15,11 +13,9 @@ namespace ConfusedPolarBear.Plugin.IntroSkipper;
 /// </summary>
 public class DetectIntroductionsTask : IScheduledTask
 {
-    private readonly ILogger<DetectIntroductionsTask> _logger;
-
     private readonly ILoggerFactory _loggerFactory;
 
-    private readonly ILibraryManager? _libraryManager;
+    private readonly ILibraryManager _libraryManager;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="DetectIntroductionsTask"/> class.
@@ -28,21 +24,10 @@ public class DetectIntroductionsTask : IScheduledTask
     /// <param name="libraryManager">Library manager.</param>
     public DetectIntroductionsTask(
         ILoggerFactory loggerFactory,
-        ILibraryManager libraryManager) : this(loggerFactory)
+        ILibraryManager libraryManager)
     {
-        _libraryManager = libraryManager;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="DetectIntroductionsTask"/> class.
-    /// </summary>
-    /// <param name="loggerFactory">Logger factory.</param>
-    public DetectIntroductionsTask(ILoggerFactory loggerFactory)
-    {
-        _logger = loggerFactory.CreateLogger<DetectIntroductionsTask>();
         _loggerFactory = loggerFactory;
-
-        EdlManager.Initialize(_logger);
+        _libraryManager = libraryManager;
     }
 
     /// <summary>
@@ -75,151 +60,20 @@ public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellat
     {
         if (_libraryManager is null)
         {
-            throw new InvalidOperationException("Library manager must not be null");
+            throw new InvalidOperationException("Library manager was null");
         }
 
-        // Make sure the analysis queue matches what's currently in Jellyfin.
-        var queueManager = new QueueManager(
-            _loggerFactory.CreateLogger<QueueManager>(),
+        var baseAnalyzer = new BaseItemAnalyzerTask(
+            AnalysisMode.Introduction,
+            _loggerFactory.CreateLogger<DetectIntroductionsTask>(),
+            _loggerFactory,
             _libraryManager);
 
-        var queue = queueManager.GetMediaItems();
-
-        if (queue.Count == 0)
-        {
-            throw new FingerprintException(
-                "No episodes to analyze. If you are limiting the list of libraries to analyze, check that all library names have been spelled correctly.");
-        }
-
-        // Log EDL settings
-        EdlManager.LogConfiguration();
-
-        var totalProcessed = 0;
-        var options = new ParallelOptions()
-        {
-            MaxDegreeOfParallelism = Plugin.Instance!.Configuration.MaxParallelism
-        };
-
-        // Analyze all episodes in the queue using the degrees of parallelism the user specified.
-        Parallel.ForEach(queue, options, (season) =>
-        {
-            // Since the first run of the task can run for multiple hours, ensure that none
-            // of the current media items were deleted from Jellyfin since the task was started.
-            var (episodes, unanalyzed) = queueManager.VerifyQueue(
-                season.Value.AsReadOnly(),
-                AnalysisMode.Introduction);
-
-            if (episodes.Count == 0)
-            {
-                return;
-            }
-
-            var first = episodes[0];
-            var writeEdl = false;
-
-            if (!unanalyzed)
-            {
-                _logger.LogDebug(
-                    "All episodes in {Name} season {Season} have already been analyzed",
-                    first.SeriesName,
-                    first.SeasonNumber);
-
-                return;
-            }
-
-            try
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                // Increment totalProcessed by the number of episodes in this season that were actually analyzed
-                // (instead of just using the number of episodes in the current season).
-                var analyzed = AnalyzeSeason(episodes, cancellationToken);
-                Interlocked.Add(ref totalProcessed, analyzed);
-                writeEdl = analyzed > 0 || Plugin.Instance!.Configuration.RegenerateEdlFiles;
-            }
-            catch (FingerprintException ex)
-            {
-                _logger.LogWarning(
-                    "Unable to analyze {Series} season {Season}: unable to fingerprint: {Ex}",
-                    first.SeriesName,
-                    first.SeasonNumber,
-                    ex);
-            }
-            catch (KeyNotFoundException ex)
-            {
-                _logger.LogWarning(
-                    "Unable to analyze {Series} season {Season}: cache miss: {Ex}",
-                    first.SeriesName,
-                    first.SeasonNumber,
-                    ex);
-            }
-
-            if (writeEdl && Plugin.Instance!.Configuration.EdlAction != EdlAction.None)
-            {
-                EdlManager.UpdateEDLFiles(episodes);
-            }
-
-            var total = Plugin.Instance!.TotalQueued;
-            if (total > 0)
-            {
-                progress.Report((totalProcessed * 100) / total);
-            }
-        });
-
-        // Turn the regenerate EDL flag off after the scan completes.
-        if (Plugin.Instance!.Configuration.RegenerateEdlFiles)
-        {
-            _logger.LogInformation("Turning EDL file regeneration flag off");
-            Plugin.Instance!.Configuration.RegenerateEdlFiles = false;
-            Plugin.Instance!.SaveConfiguration();
-        }
+        baseAnalyzer.AnalyzeItems(progress, cancellationToken);
 
         return Task.CompletedTask;
     }
 
-    /// <summary>
-    /// Fingerprints all episodes in the provided season and stores the timestamps of all introductions.
-    /// </summary>
-    /// <param name="episodes">Episodes in this season.</param>
-    /// <param name="cancellationToken">Cancellation token provided by the scheduled task.</param>
-    /// <returns>Number of episodes from the provided season that were analyzed.</returns>
-    private int AnalyzeSeason(
-        ReadOnlyCollection<QueuedEpisode> episodes,
-        CancellationToken cancellationToken)
-    {
-        // Skip seasons with an insufficient number of episodes.
-        if (episodes.Count <= 1)
-        {
-            return episodes.Count;
-        }
-
-        // Only analyze specials (season 0) if the user has opted in.
-        var first = episodes[0];
-        if (first.SeasonNumber == 0 && !Plugin.Instance!.Configuration.AnalyzeSeasonZero)
-        {
-            return 0;
-        }
-
-        _logger.LogInformation(
-            "Analyzing {Count} episodes from {Name} season {Season}",
-            episodes.Count,
-            first.SeriesName,
-            first.SeasonNumber);
-
-        // Chapter analyzer
-        var chapter = new ChapterAnalyzer(_loggerFactory.CreateLogger<ChapterAnalyzer>());
-        episodes = chapter.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);
-
-        // Analyze the season with Chromaprint
-        var chromaprint = new ChromaprintAnalyzer(_loggerFactory.CreateLogger<ChromaprintAnalyzer>());
-        chromaprint.AnalyzeMediaFiles(episodes, AnalysisMode.Introduction, cancellationToken);
-
-        return episodes.Count;
-    }
-
     /// <summary>
     /// Get task triggers.
     /// </summary>

From c6801d57c629de265f47b2eabc1ae32d46b9b24d Mon Sep 17 00:00:00 2001
From: ConfusedPolarBear <33811686+ConfusedPolarBear@users.noreply.github.com>
Date: Thu, 2 Feb 2023 03:52:31 -0600
Subject: [PATCH 22/22] Fix progress bar

---
 .../ScheduledTasks/BaseItemAnalyzerTask.cs                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs
index 6a8f50e..940e0a0 100644
--- a/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs
+++ b/ConfusedPolarBear.Plugin.IntroSkipper/ScheduledTasks/BaseItemAnalyzerTask.cs
@@ -193,6 +193,6 @@ private int AnalyzeItems(
             items = analyzer.AnalyzeMediaFiles(items, this._analysisMode, cancellationToken);
         }
 
-        return totalItems - items.Count;
+        return totalItems;
     }
 }