| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.IO; |
| | | 4 | | using System.Linq; |
| | | 5 | | using System.Threading; |
| | | 6 | | using System.Threading.Tasks; |
| | | 7 | | using Jellyfin.Extensions; |
| | | 8 | | using MediaBrowser.Controller.Chapters; |
| | | 9 | | using MediaBrowser.Controller.Entities; |
| | | 10 | | using MediaBrowser.Controller.Entities.Audio; |
| | | 11 | | using MediaBrowser.Controller.IO; |
| | | 12 | | using MediaBrowser.Controller.Library; |
| | | 13 | | using MediaBrowser.Controller.MediaEncoding; |
| | | 14 | | using MediaBrowser.Controller.Persistence; |
| | | 15 | | using MediaBrowser.Controller.Providers; |
| | | 16 | | using MediaBrowser.Model.Configuration; |
| | | 17 | | using MediaBrowser.Model.Dto; |
| | | 18 | | using MediaBrowser.Model.Entities; |
| | | 19 | | using MediaBrowser.Model.IO; |
| | | 20 | | using MediaBrowser.Model.MediaInfo; |
| | | 21 | | using Microsoft.Extensions.Logging; |
| | | 22 | | |
| | | 23 | | namespace Emby.Server.Implementations.Chapters; |
| | | 24 | | |
| | | 25 | | /// <summary> |
| | | 26 | | /// The chapter manager. |
| | | 27 | | /// </summary> |
| | | 28 | | public class ChapterManager : IChapterManager |
| | | 29 | | { |
| | | 30 | | private readonly IFileSystem _fileSystem; |
| | | 31 | | private readonly ILogger<ChapterManager> _logger; |
| | | 32 | | private readonly IMediaEncoder _encoder; |
| | | 33 | | private readonly IChapterRepository _chapterRepository; |
| | | 34 | | private readonly ILibraryManager _libraryManager; |
| | | 35 | | private readonly IPathManager _pathManager; |
| | | 36 | | |
| | | 37 | | /// <summary> |
| | | 38 | | /// The first chapter ticks. |
| | | 39 | | /// </summary> |
| | 0 | 40 | | private static readonly long _firstChapterTicks = TimeSpan.FromSeconds(15).Ticks; |
| | | 41 | | |
| | | 42 | | /// <summary> |
| | | 43 | | /// Initializes a new instance of the <see cref="ChapterManager"/> class. |
| | | 44 | | /// </summary> |
| | | 45 | | /// <param name="logger">The <see cref="ILogger{ChapterManager}"/>.</param> |
| | | 46 | | /// <param name="fileSystem">The <see cref="IFileSystem"/>.</param> |
| | | 47 | | /// <param name="encoder">The <see cref="IMediaEncoder"/>.</param> |
| | | 48 | | /// <param name="chapterRepository">The <see cref="IChapterRepository"/>.</param> |
| | | 49 | | /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param> |
| | | 50 | | /// <param name="pathManager">The <see cref="IPathManager"/>.</param> |
| | | 51 | | public ChapterManager( |
| | | 52 | | ILogger<ChapterManager> logger, |
| | | 53 | | IFileSystem fileSystem, |
| | | 54 | | IMediaEncoder encoder, |
| | | 55 | | IChapterRepository chapterRepository, |
| | | 56 | | ILibraryManager libraryManager, |
| | | 57 | | IPathManager pathManager) |
| | | 58 | | { |
| | 27 | 59 | | _logger = logger; |
| | 27 | 60 | | _fileSystem = fileSystem; |
| | 27 | 61 | | _encoder = encoder; |
| | 27 | 62 | | _chapterRepository = chapterRepository; |
| | 27 | 63 | | _libraryManager = libraryManager; |
| | 27 | 64 | | _pathManager = pathManager; |
| | 27 | 65 | | } |
| | | 66 | | |
| | | 67 | | /// <summary> |
| | | 68 | | /// Determines whether [is eligible for chapter image extraction] [the specified video]. |
| | | 69 | | /// </summary> |
| | | 70 | | /// <param name="video">The video.</param> |
| | | 71 | | /// <param name="libraryOptions">The library options for the video.</param> |
| | | 72 | | /// <returns><c>true</c> if [is eligible for chapter image extraction] [the specified video]; otherwise, <c>false</c |
| | | 73 | | private bool IsEligibleForChapterImageExtraction(Video video, LibraryOptions libraryOptions) |
| | | 74 | | { |
| | 0 | 75 | | if (video.IsPlaceHolder) |
| | | 76 | | { |
| | 0 | 77 | | return false; |
| | | 78 | | } |
| | | 79 | | |
| | 0 | 80 | | if (libraryOptions is null || !libraryOptions.EnableChapterImageExtraction) |
| | | 81 | | { |
| | 0 | 82 | | return false; |
| | | 83 | | } |
| | | 84 | | |
| | 0 | 85 | | if (video.IsShortcut) |
| | | 86 | | { |
| | 0 | 87 | | return false; |
| | | 88 | | } |
| | | 89 | | |
| | 0 | 90 | | if (!video.IsCompleteMedia) |
| | | 91 | | { |
| | 0 | 92 | | return false; |
| | | 93 | | } |
| | | 94 | | |
| | | 95 | | // Can't extract images if there are no video streams |
| | 0 | 96 | | return video.DefaultVideoStreamIndex.HasValue; |
| | | 97 | | } |
| | | 98 | | |
| | | 99 | | private long GetAverageDurationBetweenChapters(IReadOnlyList<ChapterInfo> chapters) |
| | | 100 | | { |
| | 0 | 101 | | if (chapters.Count < 2) |
| | | 102 | | { |
| | 0 | 103 | | return 0; |
| | | 104 | | } |
| | | 105 | | |
| | 0 | 106 | | long sum = 0; |
| | 0 | 107 | | for (int i = 1; i < chapters.Count; i++) |
| | | 108 | | { |
| | 0 | 109 | | sum += chapters[i].StartPositionTicks - chapters[i - 1].StartPositionTicks; |
| | | 110 | | } |
| | | 111 | | |
| | 0 | 112 | | return sum / chapters.Count; |
| | | 113 | | } |
| | | 114 | | |
| | | 115 | | /// <inheritdoc /> |
| | | 116 | | public async Task<bool> RefreshChapterImages(Video video, IDirectoryService directoryService, IReadOnlyList<ChapterI |
| | | 117 | | { |
| | 0 | 118 | | if (chapters.Count == 0) |
| | | 119 | | { |
| | 0 | 120 | | return true; |
| | | 121 | | } |
| | | 122 | | |
| | 0 | 123 | | var libraryOptions = _libraryManager.GetLibraryOptions(video); |
| | | 124 | | |
| | 0 | 125 | | if (!IsEligibleForChapterImageExtraction(video, libraryOptions)) |
| | | 126 | | { |
| | 0 | 127 | | extractImages = false; |
| | | 128 | | } |
| | | 129 | | |
| | 0 | 130 | | var averageChapterDuration = GetAverageDurationBetweenChapters(chapters); |
| | 0 | 131 | | var threshold = TimeSpan.FromSeconds(1).Ticks; |
| | 0 | 132 | | if (chapters.Count >= 2 && averageChapterDuration < threshold) |
| | | 133 | | { |
| | 0 | 134 | | _logger.LogInformation("Skipping chapter image extraction for {Video} as the average chapter duration {Avera |
| | 0 | 135 | | extractImages = false; |
| | | 136 | | } |
| | | 137 | | |
| | 0 | 138 | | var success = true; |
| | 0 | 139 | | var changesMade = false; |
| | 0 | 140 | | var extractedCount = 0; |
| | | 141 | | |
| | 0 | 142 | | var runtimeTicks = video.RunTimeTicks ?? 0; |
| | | 143 | | |
| | 0 | 144 | | var currentImages = GetSavedChapterImages(video, directoryService); |
| | | 145 | | |
| | 0 | 146 | | foreach (var chapter in chapters) |
| | | 147 | | { |
| | 0 | 148 | | if (chapter.StartPositionTicks >= runtimeTicks) |
| | | 149 | | { |
| | 0 | 150 | | _logger.LogInformation("Stopping chapter extraction for {0} because a chapter was found with a position |
| | 0 | 151 | | break; |
| | | 152 | | } |
| | | 153 | | |
| | 0 | 154 | | var path = _pathManager.GetChapterImagePath(video, chapter.StartPositionTicks); |
| | | 155 | | |
| | 0 | 156 | | if (!currentImages.Contains(path, StringComparison.OrdinalIgnoreCase)) |
| | | 157 | | { |
| | 0 | 158 | | if (extractImages) |
| | | 159 | | { |
| | 0 | 160 | | cancellationToken.ThrowIfCancellationRequested(); |
| | | 161 | | |
| | | 162 | | try |
| | | 163 | | { |
| | | 164 | | // Add some time for the first chapter to make sure we don't end up with a black image |
| | 0 | 165 | | var time = chapter.StartPositionTicks == 0 ? TimeSpan.FromTicks(Math.Min(_firstChapterTicks, vid |
| | | 166 | | |
| | 0 | 167 | | var inputPath = video.Path; |
| | 0 | 168 | | var directoryPath = Path.GetDirectoryName(path); |
| | 0 | 169 | | if (!string.IsNullOrEmpty(directoryPath)) |
| | | 170 | | { |
| | 0 | 171 | | Directory.CreateDirectory(directoryPath); |
| | | 172 | | } |
| | | 173 | | |
| | 0 | 174 | | var container = video.Container; |
| | 0 | 175 | | var mediaSource = new MediaSourceInfo |
| | 0 | 176 | | { |
| | 0 | 177 | | VideoType = video.VideoType, |
| | 0 | 178 | | IsoType = video.IsoType, |
| | 0 | 179 | | Protocol = video.PathProtocol ?? MediaProtocol.File, |
| | 0 | 180 | | }; |
| | | 181 | | |
| | 0 | 182 | | _logger.LogDebug("Extracting chapter image for {Name} at {Time}", video.Name, time); |
| | 0 | 183 | | var tempFile = await _encoder.ExtractVideoImage(inputPath, container, mediaSource, video.GetDefa |
| | 0 | 184 | | File.Copy(tempFile, path, true); |
| | | 185 | | |
| | | 186 | | try |
| | | 187 | | { |
| | 0 | 188 | | _fileSystem.DeleteFile(tempFile); |
| | 0 | 189 | | } |
| | 0 | 190 | | catch (IOException ex) |
| | | 191 | | { |
| | 0 | 192 | | _logger.LogError(ex, "Error deleting temporary chapter image encoding file {Path}", tempFile |
| | 0 | 193 | | } |
| | | 194 | | |
| | 0 | 195 | | chapter.ImagePath = path; |
| | 0 | 196 | | chapter.ImageDateModified = _fileSystem.GetLastWriteTimeUtc(path); |
| | 0 | 197 | | changesMade = true; |
| | 0 | 198 | | extractedCount++; |
| | 0 | 199 | | } |
| | 0 | 200 | | catch (Exception ex) |
| | | 201 | | { |
| | 0 | 202 | | _logger.LogError(ex, "Error extracting chapter images for {0}", string.Join(',', video.Path)); |
| | 0 | 203 | | success = false; |
| | 0 | 204 | | break; |
| | | 205 | | } |
| | | 206 | | } |
| | 0 | 207 | | else if (!string.IsNullOrEmpty(chapter.ImagePath)) |
| | | 208 | | { |
| | 0 | 209 | | chapter.ImagePath = null; |
| | 0 | 210 | | changesMade = true; |
| | | 211 | | } |
| | | 212 | | } |
| | 0 | 213 | | else if (!string.Equals(path, chapter.ImagePath, StringComparison.OrdinalIgnoreCase)) |
| | | 214 | | { |
| | 0 | 215 | | chapter.ImagePath = path; |
| | 0 | 216 | | chapter.ImageDateModified = _fileSystem.GetLastWriteTimeUtc(path); |
| | 0 | 217 | | changesMade = true; |
| | | 218 | | } |
| | 0 | 219 | | else if (libraryOptions?.EnableChapterImageExtraction != true) |
| | | 220 | | { |
| | | 221 | | // We have an image for the current chapter but the user has disabled chapter image extraction -> delete |
| | 0 | 222 | | chapter.ImagePath = null; |
| | 0 | 223 | | changesMade = true; |
| | | 224 | | } |
| | 0 | 225 | | } |
| | | 226 | | |
| | 0 | 227 | | if (extractedCount > 0) |
| | | 228 | | { |
| | 0 | 229 | | _logger.LogInformation("Extracted {Count} chapter images for {Name} at {Path}", extractedCount, video.Name, |
| | | 230 | | } |
| | | 231 | | |
| | 0 | 232 | | if (saveChapters && changesMade) |
| | | 233 | | { |
| | 0 | 234 | | SaveChapters(video, chapters); |
| | | 235 | | } |
| | | 236 | | |
| | 0 | 237 | | DeleteDeadImages(currentImages, chapters); |
| | | 238 | | |
| | 0 | 239 | | return success; |
| | 0 | 240 | | } |
| | | 241 | | |
| | | 242 | | /// <inheritdoc /> |
| | | 243 | | public bool Supports(BaseItem item) |
| | 0 | 244 | | => item is Video or Audio; |
| | | 245 | | |
| | | 246 | | /// <inheritdoc /> |
| | | 247 | | public void SaveChapters(BaseItem item, IReadOnlyList<ChapterInfo> chapters) |
| | | 248 | | { |
| | 0 | 249 | | if (!Supports(item)) |
| | | 250 | | { |
| | 0 | 251 | | _logger.LogWarning("Attempted to save chapters for unsupported item type {Type}: {Name} ({Id})", item.GetTyp |
| | 0 | 252 | | return; |
| | | 253 | | } |
| | | 254 | | |
| | | 255 | | // Remove any chapters that are outside of the runtime of the item |
| | 0 | 256 | | var validChapters = chapters.Where(c => c.StartPositionTicks < item.RunTimeTicks).ToList(); |
| | 0 | 257 | | _chapterRepository.SaveChapters(item.Id, validChapters); |
| | 0 | 258 | | } |
| | | 259 | | |
| | | 260 | | /// <inheritdoc /> |
| | | 261 | | public ChapterInfo? GetChapter(Guid baseItemId, int index) |
| | | 262 | | { |
| | 0 | 263 | | return _chapterRepository.GetChapter(baseItemId, index); |
| | | 264 | | } |
| | | 265 | | |
| | | 266 | | /// <inheritdoc /> |
| | | 267 | | public IReadOnlyList<ChapterInfo> GetChapters(Guid baseItemId) |
| | | 268 | | { |
| | 6 | 269 | | return _chapterRepository.GetChapters(baseItemId); |
| | | 270 | | } |
| | | 271 | | |
| | | 272 | | /// <inheritdoc /> |
| | | 273 | | public async Task DeleteChapterDataAsync(Guid itemId, CancellationToken cancellationToken) |
| | | 274 | | { |
| | 0 | 275 | | await _chapterRepository.DeleteChaptersAsync(itemId, cancellationToken).ConfigureAwait(false); |
| | 0 | 276 | | } |
| | | 277 | | |
| | | 278 | | private IReadOnlyList<string> GetSavedChapterImages(Video video, IDirectoryService directoryService) |
| | | 279 | | { |
| | 0 | 280 | | var path = _pathManager.GetChapterImageFolderPath(video); |
| | 0 | 281 | | if (!Directory.Exists(path)) |
| | | 282 | | { |
| | 0 | 283 | | return []; |
| | | 284 | | } |
| | | 285 | | |
| | | 286 | | try |
| | | 287 | | { |
| | 0 | 288 | | return directoryService.GetFilePaths(path); |
| | | 289 | | } |
| | 0 | 290 | | catch (IOException) |
| | | 291 | | { |
| | 0 | 292 | | return []; |
| | | 293 | | } |
| | 0 | 294 | | } |
| | | 295 | | |
| | | 296 | | private void DeleteDeadImages(IEnumerable<string> images, IEnumerable<ChapterInfo> chapters) |
| | | 297 | | { |
| | 0 | 298 | | var existingImages = chapters.Select(i => i.ImagePath).Where(i => !string.IsNullOrEmpty(i)); |
| | 0 | 299 | | var deadImages = images |
| | 0 | 300 | | .Except(existingImages, StringComparer.OrdinalIgnoreCase) |
| | 0 | 301 | | .Where(i => BaseItem.SupportedImageExtensions.Contains(Path.GetExtension(i.AsSpan()), StringComparison.Ordin |
| | 0 | 302 | | .ToList(); |
| | | 303 | | |
| | 0 | 304 | | foreach (var image in deadImages) |
| | | 305 | | { |
| | 0 | 306 | | _logger.LogDebug("Deleting dead chapter image {Path}", image); |
| | | 307 | | |
| | | 308 | | try |
| | | 309 | | { |
| | 0 | 310 | | _fileSystem.DeleteFile(image!); |
| | 0 | 311 | | } |
| | 0 | 312 | | catch (IOException ex) |
| | | 313 | | { |
| | 0 | 314 | | _logger.LogError(ex, "Error deleting {Path}.", image); |
| | 0 | 315 | | } |
| | | 316 | | } |
| | 0 | 317 | | } |
| | | 318 | | } |