mirror of
https://github.com/jellyfin/jellyfin.git
synced 2026-05-19 23:26:45 +01:00
19b756a507
Currently "Skip if the video already contains embedded subtitles" and "Skip if the default audio track matches the download language" are ignored because the internal tracks are not loaded before downloading This method is also triggered by the missing subtitles task (whenever a subtitle is downloaded) so if there are multiple languages configured, after first one is downloaded (valid) it runs it for other languages which might be internal
642 lines
26 KiB
C#
642 lines
26 KiB
C#
#pragma warning disable CA1068, CS1591
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Jellyfin.Data.Enums;
|
|
using Jellyfin.Extensions;
|
|
using MediaBrowser.Controller.Chapters;
|
|
using MediaBrowser.Controller.Configuration;
|
|
using MediaBrowser.Controller.Entities;
|
|
using MediaBrowser.Controller.Entities.Movies;
|
|
using MediaBrowser.Controller.Entities.TV;
|
|
using MediaBrowser.Controller.Library;
|
|
using MediaBrowser.Controller.MediaEncoding;
|
|
using MediaBrowser.Controller.Persistence;
|
|
using MediaBrowser.Controller.Providers;
|
|
using MediaBrowser.Controller.Subtitles;
|
|
using MediaBrowser.Model.Configuration;
|
|
using MediaBrowser.Model.Dlna;
|
|
using MediaBrowser.Model.Dto;
|
|
using MediaBrowser.Model.Entities;
|
|
using MediaBrowser.Model.Globalization;
|
|
using MediaBrowser.Model.MediaInfo;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace MediaBrowser.Providers.MediaInfo
|
|
{
|
|
public class FFProbeVideoInfo
|
|
{
|
|
private readonly ILogger<FFProbeVideoInfo> _logger;
|
|
private readonly IMediaSourceManager _mediaSourceManager;
|
|
private readonly IMediaEncoder _mediaEncoder;
|
|
private readonly IBlurayExaminer _blurayExaminer;
|
|
private readonly ILocalizationManager _localization;
|
|
private readonly IChapterManager _chapterManager;
|
|
private readonly IServerConfigurationManager _config;
|
|
private readonly ISubtitleManager _subtitleManager;
|
|
private readonly ILibraryManager _libraryManager;
|
|
private readonly AudioResolver _audioResolver;
|
|
private readonly SubtitleResolver _subtitleResolver;
|
|
private readonly IMediaAttachmentRepository _mediaAttachmentRepository;
|
|
private readonly IMediaStreamRepository _mediaStreamRepository;
|
|
|
|
public FFProbeVideoInfo(
|
|
ILogger<FFProbeVideoInfo> logger,
|
|
IMediaSourceManager mediaSourceManager,
|
|
IMediaEncoder mediaEncoder,
|
|
IBlurayExaminer blurayExaminer,
|
|
ILocalizationManager localization,
|
|
IChapterManager chapterManager,
|
|
IServerConfigurationManager config,
|
|
ISubtitleManager subtitleManager,
|
|
ILibraryManager libraryManager,
|
|
AudioResolver audioResolver,
|
|
SubtitleResolver subtitleResolver,
|
|
IMediaAttachmentRepository mediaAttachmentRepository,
|
|
IMediaStreamRepository mediaStreamRepository)
|
|
{
|
|
_logger = logger;
|
|
_mediaSourceManager = mediaSourceManager;
|
|
_mediaEncoder = mediaEncoder;
|
|
_blurayExaminer = blurayExaminer;
|
|
_localization = localization;
|
|
_chapterManager = chapterManager;
|
|
_config = config;
|
|
_subtitleManager = subtitleManager;
|
|
_libraryManager = libraryManager;
|
|
_audioResolver = audioResolver;
|
|
_subtitleResolver = subtitleResolver;
|
|
_mediaAttachmentRepository = mediaAttachmentRepository;
|
|
_mediaStreamRepository = mediaStreamRepository;
|
|
}
|
|
|
|
public async Task<ItemUpdateType> ProbeVideo<T>(
|
|
T item,
|
|
MetadataRefreshOptions options,
|
|
CancellationToken cancellationToken)
|
|
where T : Video
|
|
{
|
|
BlurayDiscInfo? blurayDiscInfo = null;
|
|
|
|
Model.MediaInfo.MediaInfo? mediaInfoResult = null;
|
|
|
|
if (!item.IsShortcut || options.EnableRemoteContentProbe)
|
|
{
|
|
if (item.VideoType == VideoType.Dvd)
|
|
{
|
|
// Get list of playable .vob files
|
|
var vobs = _mediaEncoder.GetPrimaryPlaylistVobFiles(item.Path, null);
|
|
|
|
// Return if no playable .vob files are found
|
|
if (vobs.Count == 0)
|
|
{
|
|
_logger.LogError("No playable .vob files found in DVD structure, skipping FFprobe.");
|
|
return ItemUpdateType.MetadataImport;
|
|
}
|
|
|
|
// Fetch metadata of first .vob file
|
|
mediaInfoResult = await GetMediaInfo(
|
|
new Video
|
|
{
|
|
Path = vobs[0]
|
|
},
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
// Sum up the runtime of all .vob files skipping the first .vob
|
|
for (var i = 1; i < vobs.Count; i++)
|
|
{
|
|
var tmpMediaInfo = await GetMediaInfo(
|
|
new Video
|
|
{
|
|
Path = vobs[i]
|
|
},
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
mediaInfoResult.RunTimeTicks += tmpMediaInfo.RunTimeTicks;
|
|
}
|
|
}
|
|
else if (item.VideoType == VideoType.BluRay)
|
|
{
|
|
// Get BD disc information
|
|
blurayDiscInfo = GetBDInfo(item.Path);
|
|
|
|
// Return if no playable .m2ts files are found
|
|
if (blurayDiscInfo is null || blurayDiscInfo.Files.Length == 0)
|
|
{
|
|
_logger.LogError("No playable .m2ts files found in Blu-ray structure, skipping FFprobe.");
|
|
return ItemUpdateType.MetadataImport;
|
|
}
|
|
|
|
// Fetch metadata of first .m2ts file
|
|
mediaInfoResult = await GetMediaInfo(
|
|
new Video
|
|
{
|
|
Path = blurayDiscInfo.Files[0]
|
|
},
|
|
cancellationToken).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
mediaInfoResult = await GetMediaInfo(item, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
await Fetch(item, cancellationToken, mediaInfoResult, blurayDiscInfo, options).ConfigureAwait(false);
|
|
|
|
return ItemUpdateType.MetadataImport;
|
|
}
|
|
|
|
private Task<Model.MediaInfo.MediaInfo> GetMediaInfo(
|
|
Video item,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
var path = item.Path;
|
|
var protocol = item.PathProtocol ?? MediaProtocol.File;
|
|
|
|
if (item.IsShortcut)
|
|
{
|
|
path = item.ShortcutPath;
|
|
protocol = _mediaSourceManager.GetPathProtocol(path);
|
|
}
|
|
|
|
return _mediaEncoder.GetMediaInfo(
|
|
new MediaInfoRequest
|
|
{
|
|
ExtractChapters = true,
|
|
MediaType = DlnaProfileType.Video,
|
|
MediaSource = new MediaSourceInfo
|
|
{
|
|
Path = path,
|
|
Protocol = protocol,
|
|
VideoType = item.VideoType,
|
|
IsoType = item.IsoType
|
|
}
|
|
},
|
|
cancellationToken);
|
|
}
|
|
|
|
protected async Task Fetch(
|
|
Video video,
|
|
CancellationToken cancellationToken,
|
|
Model.MediaInfo.MediaInfo? mediaInfo,
|
|
BlurayDiscInfo? blurayInfo,
|
|
MetadataRefreshOptions options)
|
|
{
|
|
List<MediaStream> mediaStreams = new List<MediaStream>();
|
|
IReadOnlyList<MediaAttachment> mediaAttachments;
|
|
ChapterInfo[] chapters;
|
|
|
|
await AddExternalAudioAsync(video, mediaStreams, options, cancellationToken).ConfigureAwait(false);
|
|
|
|
if (mediaInfo is not null)
|
|
{
|
|
mediaStreams.AddRange(mediaInfo.MediaStreams);
|
|
|
|
mediaAttachments = mediaInfo.MediaAttachments;
|
|
video.TotalBitrate = mediaInfo.Bitrate;
|
|
video.RunTimeTicks = mediaInfo.RunTimeTicks;
|
|
video.Container = mediaInfo.Container;
|
|
var videoType = video.VideoType;
|
|
if (videoType == VideoType.BluRay || videoType == VideoType.Dvd)
|
|
{
|
|
video.Size = mediaInfo.Size;
|
|
}
|
|
|
|
chapters = mediaInfo.Chapters ?? [];
|
|
if (blurayInfo is not null)
|
|
{
|
|
FetchBdInfo(video, ref chapters, mediaStreams, blurayInfo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var mediaStream in video.GetMediaStreams())
|
|
{
|
|
if (!mediaStream.IsExternal)
|
|
{
|
|
mediaStreams.Add(mediaStream);
|
|
}
|
|
}
|
|
|
|
mediaAttachments = [];
|
|
chapters = [];
|
|
}
|
|
|
|
// Download and insert external streams before the streams from the file to preserve stream IDs on remote videos
|
|
await AddExternalSubtitlesAsync(video, mediaStreams, options, cancellationToken).ConfigureAwait(false);
|
|
|
|
for (var i = 0; i < mediaStreams.Count; i++)
|
|
{
|
|
mediaStreams[i].Index = i;
|
|
}
|
|
|
|
var libraryOptions = _libraryManager.GetLibraryOptions(video);
|
|
|
|
if (mediaInfo is not null)
|
|
{
|
|
FetchEmbeddedInfo(video, mediaInfo, options, libraryOptions);
|
|
FetchPeople(video, mediaInfo, options);
|
|
video.Timestamp = mediaInfo.Timestamp;
|
|
video.Video3DFormat ??= mediaInfo.Video3DFormat;
|
|
}
|
|
|
|
if (libraryOptions.AllowEmbeddedSubtitles == EmbeddedSubtitleOptions.AllowText || libraryOptions.AllowEmbeddedSubtitles == EmbeddedSubtitleOptions.AllowNone)
|
|
{
|
|
_logger.LogDebug("Disabling embedded image subtitles for {Path} due to DisableEmbeddedImageSubtitles setting", video.Path);
|
|
mediaStreams.RemoveAll(i => i.Type == MediaStreamType.Subtitle && !i.IsExternal && !i.IsTextSubtitleStream);
|
|
}
|
|
|
|
if (libraryOptions.AllowEmbeddedSubtitles == EmbeddedSubtitleOptions.AllowImage || libraryOptions.AllowEmbeddedSubtitles == EmbeddedSubtitleOptions.AllowNone)
|
|
{
|
|
_logger.LogDebug("Disabling embedded text subtitles for {Path} due to DisableEmbeddedTextSubtitles setting", video.Path);
|
|
mediaStreams.RemoveAll(i => i.Type == MediaStreamType.Subtitle && !i.IsExternal && i.IsTextSubtitleStream);
|
|
}
|
|
|
|
var videoStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video);
|
|
|
|
video.Height = videoStream?.Height ?? 0;
|
|
video.Width = videoStream?.Width ?? 0;
|
|
|
|
video.DefaultVideoStreamIndex = videoStream?.Index;
|
|
|
|
video.HasSubtitles = mediaStreams.Any(i => i.Type == MediaStreamType.Subtitle);
|
|
|
|
_mediaStreamRepository.SaveMediaStreams(video.Id, mediaStreams, cancellationToken);
|
|
|
|
_mediaAttachmentRepository.SaveMediaAttachments(video.Id, mediaAttachments, cancellationToken);
|
|
|
|
if (options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh
|
|
|| options.MetadataRefreshMode == MetadataRefreshMode.Default)
|
|
{
|
|
if (_config.Configuration.DummyChapterDuration > 0 && chapters.Length == 0 && mediaStreams.Any(i => i.Type == MediaStreamType.Video))
|
|
{
|
|
chapters = CreateDummyChapters(video);
|
|
}
|
|
|
|
NormalizeChapterNames(chapters);
|
|
|
|
var extractDuringScan = false;
|
|
if (libraryOptions is not null)
|
|
{
|
|
extractDuringScan = libraryOptions.ExtractChapterImagesDuringLibraryScan;
|
|
}
|
|
|
|
await _chapterManager.RefreshChapterImages(video, options.DirectoryService, chapters, extractDuringScan, false, cancellationToken).ConfigureAwait(false);
|
|
|
|
_chapterManager.SaveChapters(video, chapters);
|
|
}
|
|
}
|
|
|
|
private void NormalizeChapterNames(ChapterInfo[] chapters)
|
|
{
|
|
for (int i = 0; i < chapters.Length; i++)
|
|
{
|
|
string? name = chapters[i].Name;
|
|
// Check if the name is empty and/or if the name is a time
|
|
// Some ripping programs do that.
|
|
if (string.IsNullOrWhiteSpace(name)
|
|
|| TimeSpan.TryParse(name, out _))
|
|
{
|
|
chapters[i].Name = string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
_localization.GetLocalizedString("ChapterNameValue"),
|
|
(i + 1).ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FetchBdInfo(Video video, ref ChapterInfo[] chapters, List<MediaStream> mediaStreams, BlurayDiscInfo blurayInfo)
|
|
{
|
|
var ffmpegVideoStream = mediaStreams.FirstOrDefault(s => s.Type == MediaStreamType.Video);
|
|
var externalStreams = mediaStreams.Where(s => s.IsExternal).ToList();
|
|
|
|
// Fill video properties from the BDInfo result
|
|
mediaStreams.Clear();
|
|
|
|
// Rebuild the list with external streams first
|
|
int index = 0;
|
|
foreach (var stream in externalStreams.Concat(blurayInfo.MediaStreams))
|
|
{
|
|
stream.Index = index++;
|
|
mediaStreams.Add(stream);
|
|
}
|
|
|
|
if (blurayInfo.RunTimeTicks.HasValue && blurayInfo.RunTimeTicks.Value > 0)
|
|
{
|
|
video.RunTimeTicks = blurayInfo.RunTimeTicks;
|
|
}
|
|
|
|
if (blurayInfo.Chapters is not null)
|
|
{
|
|
double[] brChapter = blurayInfo.Chapters;
|
|
chapters = new ChapterInfo[brChapter.Length];
|
|
for (int i = 0; i < brChapter.Length; i++)
|
|
{
|
|
chapters[i] = new ChapterInfo
|
|
{
|
|
StartPositionTicks = TimeSpan.FromSeconds(brChapter[i]).Ticks
|
|
};
|
|
}
|
|
}
|
|
|
|
var blurayVideoStream = mediaStreams.FirstOrDefault(s => s.Type == MediaStreamType.Video);
|
|
|
|
// Use the ffprobe values if these are empty
|
|
if (blurayVideoStream is not null && ffmpegVideoStream is not null)
|
|
{
|
|
// Always use ffmpeg's detected codec since that is what the rest of the codebase expects.
|
|
blurayVideoStream.Codec = ffmpegVideoStream.Codec;
|
|
blurayVideoStream.BitRate = blurayVideoStream.BitRate.GetValueOrDefault() == 0 ? ffmpegVideoStream.BitRate : blurayVideoStream.BitRate;
|
|
blurayVideoStream.Width = blurayVideoStream.Width.GetValueOrDefault() == 0 ? ffmpegVideoStream.Width : blurayVideoStream.Width;
|
|
blurayVideoStream.Height = blurayVideoStream.Height.GetValueOrDefault() == 0 ? ffmpegVideoStream.Height : blurayVideoStream.Height;
|
|
blurayVideoStream.ColorRange = ffmpegVideoStream.ColorRange;
|
|
blurayVideoStream.ColorSpace = ffmpegVideoStream.ColorSpace;
|
|
blurayVideoStream.ColorTransfer = ffmpegVideoStream.ColorTransfer;
|
|
blurayVideoStream.ColorPrimaries = ffmpegVideoStream.ColorPrimaries;
|
|
blurayVideoStream.BitDepth = ffmpegVideoStream.BitDepth;
|
|
blurayVideoStream.PixelFormat = ffmpegVideoStream.PixelFormat;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets information about the longest playlist on a bdrom.
|
|
/// </summary>
|
|
/// <param name="path">The path.</param>
|
|
/// <returns>VideoStream.</returns>
|
|
private BlurayDiscInfo? GetBDInfo(string path)
|
|
{
|
|
ArgumentException.ThrowIfNullOrEmpty(path);
|
|
|
|
try
|
|
{
|
|
return _blurayExaminer.GetDiscInfo(path);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error getting BDInfo");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private void FetchEmbeddedInfo(Video video, Model.MediaInfo.MediaInfo data, MetadataRefreshOptions refreshOptions, LibraryOptions libraryOptions)
|
|
{
|
|
var replaceData = refreshOptions.ReplaceAllMetadata;
|
|
|
|
if (!video.IsLocked && !video.LockedFields.Contains(MetadataField.OfficialRating))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(video.OfficialRating) || replaceData)
|
|
{
|
|
video.OfficialRating = data.OfficialRating;
|
|
}
|
|
}
|
|
|
|
if (!video.IsLocked && !video.LockedFields.Contains(MetadataField.Genres))
|
|
{
|
|
if (video.Genres.Length == 0 || replaceData)
|
|
{
|
|
video.Genres = [];
|
|
|
|
foreach (var genre in data.Genres.Trimmed())
|
|
{
|
|
video.AddGenre(genre);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!video.IsLocked && !video.LockedFields.Contains(MetadataField.Studios))
|
|
{
|
|
if (video.Studios.Length == 0 || replaceData)
|
|
{
|
|
video.SetStudios(data.Studios);
|
|
}
|
|
}
|
|
|
|
if (!video.IsLocked && video is MusicVideo musicVideo)
|
|
{
|
|
if (string.IsNullOrEmpty(musicVideo.Album) || replaceData)
|
|
{
|
|
musicVideo.Album = data.Album;
|
|
}
|
|
|
|
if (musicVideo.Artists.Count == 0 || replaceData)
|
|
{
|
|
musicVideo.Artists = data.Artists;
|
|
}
|
|
}
|
|
|
|
if (data.ProductionYear.HasValue)
|
|
{
|
|
if (!video.ProductionYear.HasValue || replaceData)
|
|
{
|
|
video.ProductionYear = data.ProductionYear;
|
|
}
|
|
}
|
|
|
|
if (data.PremiereDate.HasValue)
|
|
{
|
|
if (!video.PremiereDate.HasValue || replaceData)
|
|
{
|
|
video.PremiereDate = data.PremiereDate;
|
|
}
|
|
}
|
|
|
|
if (data.IndexNumber.HasValue)
|
|
{
|
|
if (!video.IndexNumber.HasValue || replaceData)
|
|
{
|
|
video.IndexNumber = data.IndexNumber;
|
|
}
|
|
}
|
|
|
|
if (data.ParentIndexNumber.HasValue)
|
|
{
|
|
if (!video.ParentIndexNumber.HasValue || replaceData)
|
|
{
|
|
video.ParentIndexNumber = data.ParentIndexNumber;
|
|
}
|
|
}
|
|
|
|
if (!video.IsLocked && !video.LockedFields.Contains(MetadataField.Name))
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(data.Name) && libraryOptions.EnableEmbeddedTitles)
|
|
{
|
|
// Separate option to use the embedded name for extras because it will often be the same name as the movie
|
|
if (!video.ExtraType.HasValue || libraryOptions.EnableEmbeddedExtrasTitles)
|
|
{
|
|
video.Name = data.Name;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(data.ForcedSortName))
|
|
{
|
|
video.ForcedSortName = data.ForcedSortName;
|
|
}
|
|
}
|
|
|
|
// If we don't have a ProductionYear try and get it from PremiereDate
|
|
if (video.PremiereDate.HasValue && !video.ProductionYear.HasValue)
|
|
{
|
|
video.ProductionYear = video.PremiereDate.Value.ToLocalTime().Year;
|
|
}
|
|
|
|
if (!video.IsLocked && !video.LockedFields.Contains(MetadataField.Overview))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(video.Overview) || replaceData)
|
|
{
|
|
video.Overview = data.Overview;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FetchPeople(Video video, Model.MediaInfo.MediaInfo data, MetadataRefreshOptions options)
|
|
{
|
|
if (video.IsLocked
|
|
|| video.LockedFields.Contains(MetadataField.Cast)
|
|
|| data.People.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (options.ReplaceAllMetadata || _libraryManager.GetPeople(video).Count == 0)
|
|
{
|
|
var people = new List<PersonInfo>();
|
|
|
|
foreach (var person in data.People)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(person.Name))
|
|
{
|
|
PeopleHelper.AddPerson(people, new PersonInfo
|
|
{
|
|
Name = person.Name,
|
|
Type = person.Type,
|
|
Role = person.Role?.Trim()
|
|
});
|
|
}
|
|
}
|
|
|
|
_libraryManager.UpdatePeople(video, people);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the external subtitles.
|
|
/// </summary>
|
|
/// <param name="video">The video.</param>
|
|
/// <param name="currentStreams">The current streams.</param>
|
|
/// <param name="options">The refreshOptions.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>Task.</returns>
|
|
private async Task AddExternalSubtitlesAsync(
|
|
Video video,
|
|
List<MediaStream> currentStreams,
|
|
MetadataRefreshOptions options,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var externalSubtitleStreams = await _subtitleResolver.GetExternalStreamsAsync(video, 0, options.DirectoryService, false, cancellationToken).ConfigureAwait(false);
|
|
|
|
var enableSubtitleDownloading = options.MetadataRefreshMode == MetadataRefreshMode.Default ||
|
|
options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh;
|
|
|
|
var libraryOptions = _libraryManager.GetLibraryOptions(video);
|
|
|
|
if (enableSubtitleDownloading && libraryOptions.SubtitleDownloadLanguages is not null)
|
|
{
|
|
var downloadedLanguages = await new SubtitleDownloader(
|
|
_logger,
|
|
_subtitleManager).DownloadSubtitles(
|
|
video,
|
|
currentStreams.Concat(externalSubtitleStreams).ToList(),
|
|
libraryOptions.SkipSubtitlesIfEmbeddedSubtitlesPresent,
|
|
libraryOptions.SkipSubtitlesIfAudioTrackMatches,
|
|
libraryOptions.RequirePerfectSubtitleMatch,
|
|
libraryOptions.SubtitleDownloadLanguages,
|
|
libraryOptions.DisabledSubtitleFetchers,
|
|
libraryOptions.SubtitleFetcherOrder,
|
|
true,
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
// Rescan
|
|
if (downloadedLanguages.Count > 0)
|
|
{
|
|
externalSubtitleStreams = await _subtitleResolver.GetExternalStreamsAsync(video, 0, options.DirectoryService, true, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
video.SubtitleFiles = externalSubtitleStreams.Select(i => i.Path).Distinct().ToArray();
|
|
|
|
currentStreams.InsertRange(0, externalSubtitleStreams);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the external audio.
|
|
/// </summary>
|
|
/// <param name="video">The video.</param>
|
|
/// <param name="currentStreams">The current streams.</param>
|
|
/// <param name="options">The refreshOptions.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
private async Task AddExternalAudioAsync(
|
|
Video video,
|
|
List<MediaStream> currentStreams,
|
|
MetadataRefreshOptions options,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var externalAudioStreams = await _audioResolver.GetExternalStreamsAsync(video, 0, options.DirectoryService, false, cancellationToken).ConfigureAwait(false);
|
|
|
|
video.AudioFiles = externalAudioStreams.Select(i => i.Path).Distinct().ToArray();
|
|
|
|
currentStreams.AddRange(externalAudioStreams);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates dummy chapters.
|
|
/// </summary>
|
|
/// <param name="video">The video.</param>
|
|
/// <returns>An array of dummy chapters.</returns>
|
|
internal ChapterInfo[] CreateDummyChapters(Video video)
|
|
{
|
|
var runtime = video.RunTimeTicks.GetValueOrDefault();
|
|
|
|
// Only process files with a runtime greater than 0 and less than 12h. The latter are likely corrupted.
|
|
if (runtime < 0 || runtime > TimeSpan.FromHours(12).Ticks)
|
|
{
|
|
throw new ArgumentException(
|
|
string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
"{0} has an invalid runtime of {1} minutes",
|
|
video.Name,
|
|
TimeSpan.FromTicks(runtime).TotalMinutes));
|
|
}
|
|
|
|
long dummyChapterDuration = TimeSpan.FromSeconds(_config.Configuration.DummyChapterDuration).Ticks;
|
|
if (runtime <= dummyChapterDuration)
|
|
{
|
|
return [];
|
|
}
|
|
|
|
int chapterCount = (int)(runtime / dummyChapterDuration);
|
|
var chapters = new ChapterInfo[chapterCount];
|
|
|
|
long currentChapterTicks = 0;
|
|
for (int i = 0; i < chapterCount; i++)
|
|
{
|
|
chapters[i] = new ChapterInfo
|
|
{
|
|
StartPositionTicks = currentChapterTicks
|
|
};
|
|
|
|
currentChapterTicks += dummyChapterDuration;
|
|
}
|
|
|
|
return chapters;
|
|
}
|
|
}
|
|
}
|