use table for collections ui (#132)

* add paging to playouts

* add sorting, paging to schedules

* fix channels sorting; add channels paging

.gitignore

@@ -40,3 +40,6 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+
+docker-compose.override.yml
+

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -73,13 +73,12 @@ namespace ErsatzTV.Application.Channels.Commands
                 .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
         private Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
-            Optional(createChannel.PreferredLanguageCode)
+            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
                 .Filter(
                     lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
                         ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
                 .ToValidation<BaseError>("Preferred language code is invalid");
 
-
         private async Task<Validation<BaseError, string>> ValidateNumber(CreateChannel createChannel)
         {
             Option<Channel> maybeExistingChannel = await _channelRepository.GetByNumber(createChannel.Number);

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -82,7 +82,7 @@ namespace ErsatzTV.Application.Channels.Commands
         private async Task<Validation<BaseError, string>> ValidateNumber(UpdateChannel updateChannel)
         {
             Option<Channel> match = await _channelRepository.GetByNumber(updateChannel.Number);
-            int matchId = match.Map(c => c.Id).IfNone(updateChannel.ChannelId);
+            int matchId = await match.Map(c => c.Id).IfNoneAsync(updateChannel.ChannelId);
             if (matchId == updateChannel.ChannelId)
             {
                 if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
@@ -97,7 +97,7 @@ namespace ErsatzTV.Application.Channels.Commands
         }
 
         private Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
-            Optional(updateChannel.PreferredLanguageCode)
+            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
                 .Filter(
                     lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
                         ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -2,11 +2,20 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="MediatR" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -11,17 +11,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -43,19 +43,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     Transcode = request.Transcode,
                     HardwareAcceleration = request.HardwareAcceleration,
                     ResolutionId = resolutionId,
-                    NormalizeResolution = request.NormalizeResolution,
+                    NormalizeVideo = request.NormalizeVideo,
                     VideoCodec = request.VideoCodec,
-                    NormalizeVideoCodec = request.NormalizeVideoCodec,
                     VideoBitrate = request.VideoBitrate,
                     VideoBufferSize = request.VideoBufferSize,
                     AudioCodec = request.AudioCodec,
-                    NormalizeAudioCodec = request.NormalizeAudioCodec,
                     AudioBitrate = request.AudioBitrate,
                     AudioBufferSize = request.AudioBufferSize,
-                    AudioVolume = request.AudioVolume,
+                    NormalizeLoudness= request.NormalizeLoudness,
                     AudioChannels = request.AudioChannels,
                     AudioSampleRate = request.AudioSampleRate,
-                    NormalizeAudio = request.NormalizeAudio
+                    NormalizeAudio = request.NormalizeAudio,
+                    FrameRate = request.FrameRate
                 });
 
         private Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
@@ -63,7 +62,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => createFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
-            createFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(CreateFFmpegProfile createFFmpegProfile) =>
             (await _resolutionRepository.Get(createFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -12,17 +12,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         int ResolutionId,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+        bool NormalizeAudio,
+        string FrameRate) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -37,19 +37,18 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.Transcode = update.Transcode;
             p.HardwareAcceleration = update.HardwareAcceleration;
             p.ResolutionId = update.ResolutionId;
-            p.NormalizeResolution = update.NormalizeResolution;
+            p.NormalizeVideo = update.NormalizeVideo;
             p.VideoCodec = update.VideoCodec;
-            p.NormalizeVideoCodec = update.NormalizeVideoCodec;
             p.VideoBitrate = update.VideoBitrate;
             p.VideoBufferSize = update.VideoBufferSize;
             p.AudioCodec = update.AudioCodec;
-            p.NormalizeAudioCodec = update.NormalizeAudioCodec;
             p.AudioBitrate = update.AudioBitrate;
             p.AudioBufferSize = update.AudioBufferSize;
-            p.AudioVolume = update.AudioVolume;
+            p.NormalizeLoudness = update.NormalizeLoudness;
             p.AudioChannels = update.AudioChannels;
             p.AudioSampleRate = update.AudioSampleRate;
             p.NormalizeAudio = update.NormalizeAudio;
+            p.FrameRate = update.FrameRate;
             await _ffmpegProfileRepository.Update(p);
             return ProjectToViewModel(p);
         }
@@ -69,7 +68,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
 
         private Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
-            updateFFmpegProfile.AtLeast(1)(p => p.ThreadCount);
+            updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
 
         private async Task<Validation<BaseError, int>> ResolutionMustExist(UpdateFFmpegProfile updateFFmpegProfile) =>
             (await _resolutionRepository.Get(updateFFmpegProfile.ResolutionId))

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -71,87 +71,32 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
 
         private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
         {
-            await _configElementRepository.Get(ConfigElementKey.FFmpegPath).Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFmpegPath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFmpegPath.Key, Value = request.Settings.FFmpegPath };
-                    _configElementRepository.Add(ce);
-                });
-
-            await _configElementRepository.Get(ConfigElementKey.FFprobePath).Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.FFprobePath;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                        { Key = ConfigElementKey.FFprobePath.Key, Value = request.Settings.FFprobePath };
-                    _configElementRepository.Add(ce);
-                });
-
-            await _configElementRepository.Get(ConfigElementKey.FFmpegDefaultProfileId).Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.DefaultFFmpegProfileId.ToString();
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                    {
-                        Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
-                        Value = request.Settings.DefaultFFmpegProfileId.ToString()
-                    };
-                    _configElementRepository.Add(ce);
-                });
-
-            await _configElementRepository.Get(ConfigElementKey.FFmpegSaveReports).Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.SaveReports.ToString();
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                    {
-                        Key = ConfigElementKey.FFmpegSaveReports.Key,
-                        Value = request.Settings.SaveReports.ToString()
-                    };
-                    _configElementRepository.Add(ce);
-                });
+            await Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
+            await Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
+            await Upsert(ConfigElementKey.FFmpegDefaultProfileId, request.Settings.DefaultFFmpegProfileId.ToString());
+            await Upsert(ConfigElementKey.FFmpegSaveReports, request.Settings.SaveReports.ToString());
 
             if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
             {
                 Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
             }
 
-            await _configElementRepository.Get(ConfigElementKey.FFmpegPreferredLanguageCode).Match(
-                ce =>
-                {
-                    ce.Value = request.Settings.PreferredLanguageCode;
-                    _configElementRepository.Update(ce);
-                },
-                () =>
-                {
-                    var ce = new ConfigElement
-                    {
-                        Key = ConfigElementKey.FFmpegPreferredLanguageCode.Key,
-                        Value = request.Settings.PreferredLanguageCode
-                    };
-                    _configElementRepository.Add(ce);
-                });
-
+            await Upsert(ConfigElementKey.FFmpegPreferredLanguageCode, request.Settings.PreferredLanguageCode);
 
             return Unit.Default;
         }
+
+        private Task Upsert(ConfigElementKey key, string value) =>
+            _configElementRepository.Get(key).Match(
+                ce =>
+                {
+                    ce.Value = value;
+                    return _configElementRepository.Update(ce);
+                },
+                () =>
+                {
+                    var ce = new ConfigElement { Key = key.Key, Value = value };
+                    return _configElementRepository.Add(ce);
+                });
     }
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -10,17 +10,16 @@ namespace ErsatzTV.Application.FFmpegProfiles
         bool Transcode,
         HardwareAccelerationKind HardwareAcceleration,
         ResolutionViewModel Resolution,
-        bool NormalizeResolution,
+        bool NormalizeVideo,
         string VideoCodec,
-        bool NormalizeVideoCodec,
         int VideoBitrate,
         int VideoBufferSize,
         string AudioCodec,
-        bool NormalizeAudioCodec,
         int AudioBitrate,
         int AudioBufferSize,
-        int AudioVolume,
+        bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio);
+        bool NormalizeAudio,
+        string FrameRate);
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -13,19 +13,18 @@ namespace ErsatzTV.Application.FFmpegProfiles
                 profile.Transcode,
                 profile.HardwareAcceleration,
                 Project(profile.Resolution),
-                profile.NormalizeResolution,
+                profile.NormalizeVideo,
                 profile.VideoCodec,
-                profile.NormalizeVideoCodec,
                 profile.VideoBitrate,
                 profile.VideoBufferSize,
                 profile.AudioCodec,
-                profile.NormalizeAudioCodec,
                 profile.AudioBitrate,
                 profile.AudioBufferSize,
-                profile.AudioVolume,
+                profile.NormalizeLoudness,
                 profile.AudioChannels,
                 profile.AudioSampleRate,
-                profile.NormalizeAudio);
+                profile.NormalizeAudio,
+                profile.FrameRate);
 
         private static ResolutionViewModel Project(Resolution resolution) =>
             new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -29,11 +29,11 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
 
             return new FFmpegSettingsViewModel
             {
-                FFmpegPath = ffmpegPath.IfNone(string.Empty),
-                FFprobePath = ffprobePath.IfNone(string.Empty),
-                DefaultFFmpegProfileId = defaultFFmpegProfileId.IfNone(0),
-                SaveReports = saveReports.IfNone(false),
-                PreferredLanguageCode = preferredLanguageCode.IfNone("eng")
+                FFmpegPath = await ffmpegPath.IfNoneAsync(string.Empty),
+                FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
+                DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
+                SaveReports = await saveReports.IfNoneAsync(false),
+                PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng")
             };
         }
     }

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -18,7 +18,11 @@ namespace ErsatzTV.Application.Libraries.Queries
 
         public Task<List<LibraryViewModel>> Handle(GetAllLibraries request, CancellationToken cancellationToken) =>
             _libraryRepository.GetAll()
-                .Map(list => list.Filter(ShouldIncludeLibrary).Map(ProjectToViewModel).ToList());
+                .Map(
+                    list => list.Filter(ShouldIncludeLibrary)
+                        .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
+                        .ThenBy(l => l.MediaKind)
+                        .Map(ProjectToViewModel).ToList());
 
         private static bool ShouldIncludeLibrary(Library library) =>
             library switch

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -7,7 +7,8 @@ namespace ErsatzTV.Application.MediaCards
         List<MovieCardViewModel> MovieCards,
         List<TelevisionShowCardViewModel> ShowCards,
         List<TelevisionSeasonCardViewModel> SeasonCards,
-        List<TelevisionEpisodeCardViewModel> EpisodeCards)
+        List<TelevisionEpisodeCardViewModel> EpisodeCards,
+        List<MusicVideoCardViewModel> MusicVideoCards)
     {
         public bool UseCustomPlaybackOrder { get; set; }
     }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -52,6 +52,14 @@ namespace ErsatzTV.Application.MediaCards
                 movieMetadata.SortTitle,
                 GetPoster(movieMetadata));
 
+        internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
+            new(
+                musicVideoMetadata.MusicVideoId,
+                $"{musicVideoMetadata.Title} ({musicVideoMetadata.Artist})",
+                musicVideoMetadata.Year?.ToString(),
+                musicVideoMetadata.SortTitle,
+                GetThumbnail(musicVideoMetadata));
+
         internal static CollectionCardResultsViewModel
             ProjectToViewModel(Collection collection) =>
             new(
@@ -64,6 +72,8 @@ namespace ErsatzTV.Application.MediaCards
                 collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<Season>().Map(ProjectToViewModel).ToList(),
                 collection.MediaItems.OfType<Episode>().Map(e => ProjectToViewModel(e.EpisodeMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>

ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MusicVideoCardResultsViewModel(
+        int Count,
+        List<MusicVideoCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

@@ -0,0 +1,13 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record MusicVideoCardViewModel
+        (int MusicVideoId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            MusicVideoId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster)
+    {
+        public int CustomIndex { get; set; }
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -5,5 +5,9 @@ using LanguageExt;
 namespace ErsatzTV.Application.MediaCollections.Commands
 {
     public record AddItemsToCollection
-        (int CollectionId, List<int> MovieIds, List<int> ShowIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+    (
+        int CollectionId,
+        List<int> MovieIds,
+        List<int> ShowIds,
+        List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -41,7 +41,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         {
             if (await _mediaCollectionRepository.AddMediaItems(
                 request.CollectionId,
-                request.MovieIds.Append(request.ShowIds).ToList()))
+                request.MovieIds.Append(request.ShowIds).Append(request.MusicVideoIds).ToList()))
             {
                 // rebuild all playouts that use this collection
                 foreach (int playoutId in await _mediaCollectionRepository

ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddMusicVideoToCollection
+        (int CollectionId, int MusicVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs

@@ -0,0 +1,68 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class
+        AddMusicVideoToCollectionHandler : MediatR.IRequestHandler<AddMusicVideoToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+        private readonly IMusicVideoRepository _musicVideoRepository;
+
+        public AddMusicVideoToCollectionHandler(
+            IMediaCollectionRepository mediaCollectionRepository,
+            IMusicVideoRepository musicVideoRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _musicVideoRepository = musicVideoRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            AddMusicVideoToCollection request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => ApplyAddMusicVideoRequest(request))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> ApplyAddMusicVideoRequest(AddMusicVideoToCollection request)
+        {
+            if (await _mediaCollectionRepository.AddMediaItem(request.CollectionId, request.MusicVideoId))
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(request.CollectionId))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, Unit>> Validate(AddMusicVideoToCollection request) =>
+            (await CollectionMustExist(request), await ValidateMusicVideo(request))
+            .Apply((_, _) => Unit.Default);
+
+        private Task<Validation<BaseError, Unit>> CollectionMustExist(AddMusicVideoToCollection request) =>
+            _mediaCollectionRepository.GetCollectionWithItems(request.CollectionId)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Collection does not exist."));
+
+        private Task<Validation<BaseError, Unit>> ValidateMusicVideo(AddMusicVideoToCollection request) =>
+            LoadMusicVideo(request)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Music video does not exist"));
+
+        private Task<Option<MusicVideo>> LoadMusicVideo(AddMusicVideoToCollection request) =>
+            _musicVideoRepository.GetMusicVideo(request.MusicVideoId);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs

@@ -39,7 +39,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                 Option<CollectionItem> maybeCollectionItem =
                     c.CollectionItems.FirstOrDefault(ci => ci.MediaItemId == updateItem.MediaItemId);
 
-                maybeCollectionItem.IfSome(ci => ci.CustomIndex = updateItem.CustomIndex);
+                await maybeCollectionItem.IfSomeAsync(ci => ci.CustomIndex = updateItem.CustomIndex);
             }
 
             if (await _mediaCollectionRepository.Update(c))

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -32,7 +32,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         private async Task<Unit> ApplyUpdateRequest(Collection c, UpdateCollection request)
         {
             c.Name = request.Name;
-            request.UseCustomPlaybackOrder.IfSome(
+            await request.UseCustomPlaybackOrder.IfSomeAsync(
                 useCustomPlaybackOrder => c.UseCustomPlaybackOrder = useCustomPlaybackOrder);
             if (await _mediaCollectionRepository.Update(c) && request.UseCustomPlaybackOrder.IsSome)
             {

ErsatzTV.Application/MediaItems/Mapper.cs

@@ -1,5 +1,4 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaItems
 {
@@ -8,59 +7,6 @@ namespace ErsatzTV.Application.MediaItems
         internal static MediaItemViewModel ProjectToViewModel(MediaItem mediaItem) =>
             new(mediaItem.Id, mediaItem.LibraryPathId);
 
-        internal static MediaItemSearchResultViewModel ProjectToSearchViewModel(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Episode e => ProjectToSearchViewModel(e),
-                Movie m => ProjectToSearchViewModel(m),
-                _ => throw new ArgumentOutOfRangeException()
-            };
-
-        private static MediaItemSearchResultViewModel ProjectToSearchViewModel(Episode mediaItem) =>
-            new(
-                mediaItem.Id,
-                GetLibraryName(mediaItem),
-                "TV Show",
-                GetDisplayTitle(mediaItem),
-                GetDisplayDuration(mediaItem));
-
-        private static MediaItemSearchResultViewModel ProjectToSearchViewModel(Movie mediaItem) =>
-            new(
-                mediaItem.Id,
-                GetLibraryName(mediaItem),
-                "Movie",
-                GetDisplayTitle(mediaItem),
-                GetDisplayDuration(mediaItem));
-
-
-        private static string GetDisplayTitle(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone()
-                    .Map(em => $"{em.Title} - s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00}")
-                    .IfNone("[unknown episode]"),
-                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]"),
-                _ => string.Empty
-            };
-
-        private static string GetDisplayDuration(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem switch
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
-            };
-
-            return string.Format(
-                version.Duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                version.Duration);
-        }
-
-        // TODO: fix this when search is reimplemented
-        private static string GetLibraryName(MediaItem item) =>
-            "Library Name";
-
         public static NamedMediaItemViewModel ProjectToViewModel(Show show) =>
             new(show.Id, show.ShowMetadata.HeadOrNone().Map(sm => $"{sm?.Title} ({sm?.Year})").IfNone("???"));
 

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibrary.cs

@@ -8,15 +8,24 @@ namespace ErsatzTV.Application.MediaSources.Commands
     {
         int LibraryId { get; }
         bool ForceScan { get; }
+        bool Rescan { get; }
     }
 
     public record ScanLocalLibraryIfNeeded(int LibraryId) : IScanLocalLibrary
     {
         public bool ForceScan => false;
+        public bool Rescan => false;
     }
 
     public record ForceScanLocalLibrary(int LibraryId) : IScanLocalLibrary
     {
         public bool ForceScan => true;
+        public bool Rescan => false;
+    }
+
+    public record ForceRescanLocalLibrary(int LibraryId) : IScanLocalLibrary
+    {
+        public bool ForceScan => true;
+        public bool Rescan => true;
     }
 }

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -16,13 +16,15 @@ using Unit = LanguageExt.Unit;
 namespace ErsatzTV.Application.MediaSources.Commands
 {
     public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
-        IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
+        IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>,
+        IRequestHandler<ForceRescanLocalLibrary, Either<BaseError, string>>
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly IEntityLocker _entityLocker;
         private readonly ILibraryRepository _libraryRepository;
         private readonly ILogger<ScanLocalLibraryHandler> _logger;
         private readonly IMovieFolderScanner _movieFolderScanner;
+        private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
         private readonly ITelevisionFolderScanner _televisionFolderScanner;
 
         public ScanLocalLibraryHandler(
@@ -30,6 +32,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
             IConfigElementRepository configElementRepository,
             IMovieFolderScanner movieFolderScanner,
             ITelevisionFolderScanner televisionFolderScanner,
+            IMusicVideoFolderScanner musicVideoFolderScanner,
             IEntityLocker entityLocker,
             ILogger<ScanLocalLibraryHandler> logger)
         {
@@ -37,10 +40,15 @@ namespace ErsatzTV.Application.MediaSources.Commands
             _configElementRepository = configElementRepository;
             _movieFolderScanner = movieFolderScanner;
             _televisionFolderScanner = televisionFolderScanner;
+            _musicVideoFolderScanner = musicVideoFolderScanner;
             _entityLocker = entityLocker;
             _logger = logger;
         }
 
+        public Task<Either<BaseError, string>> Handle(
+            ForceRescanLocalLibrary request,
+            CancellationToken cancellationToken) => Handle(request);
+
         public Task<Either<BaseError, string>> Handle(
             ForceScanLocalLibrary request,
             CancellationToken cancellationToken) => Handle(request);
@@ -57,7 +65,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
 
         private async Task<Unit> PerformScan(RequestParameters parameters)
         {
-            (LocalLibrary localLibrary, string ffprobePath, bool forceScan) = parameters;
+            (LocalLibrary localLibrary, string ffprobePath, bool forceScan, bool rescan) = parameters;
 
             var lastScan = new DateTimeOffset(localLibrary.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
             if (forceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
@@ -65,15 +73,20 @@ namespace ErsatzTV.Application.MediaSources.Commands
                 var sw = new Stopwatch();
                 sw.Start();
 
+                DateTimeOffset effectiveLastScan = rescan ? DateTimeOffset.MinValue : lastScan;
+
                 foreach (LibraryPath libraryPath in localLibrary.Paths)
                 {
                     switch (localLibrary.MediaKind)
                     {
                         case LibraryMediaKind.Movies:
-                            await _movieFolderScanner.ScanFolder(libraryPath, ffprobePath, lastScan);
+                            await _movieFolderScanner.ScanFolder(libraryPath, ffprobePath, effectiveLastScan);
                             break;
                         case LibraryMediaKind.Shows:
-                            await _televisionFolderScanner.ScanFolder(libraryPath, ffprobePath, lastScan);
+                            await _televisionFolderScanner.ScanFolder(libraryPath, ffprobePath, effectiveLastScan);
+                            break;
+                        case LibraryMediaKind.MusicVideos:
+                            await _musicVideoFolderScanner.ScanFolder(libraryPath, ffprobePath, effectiveLastScan);
                             break;
                     }
                 }
@@ -104,7 +117,8 @@ namespace ErsatzTV.Application.MediaSources.Commands
                 (library, ffprobePath) => new RequestParameters(
                     library,
                     ffprobePath,
-                    request.ForceScan));
+                    request.ForceScan,
+                    request.Rescan));
 
         private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
             IScanLocalLibrary request) =>
@@ -119,6 +133,6 @@ namespace ErsatzTV.Application.MediaSources.Commands
                     ffprobePath =>
                         ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
 
-        private record RequestParameters(LocalLibrary LocalLibrary, string FFprobePath, bool ForceScan);
+        private record RequestParameters(LocalLibrary LocalLibrary, string FFprobePath, bool ForceScan, bool Rescan);
     }
 }

ErsatzTV.Application/Playouts/Mapper.cs

@@ -24,15 +24,25 @@ namespace ErsatzTV.Application.Playouts
         private static PlayoutProgramScheduleViewModel Project(ProgramSchedule programSchedule) =>
             new(programSchedule.Id, programSchedule.Name);
 
-        private static string GetDisplayTitle(MediaItem mediaItem) =>
-            mediaItem switch
+        private static string GetDisplayTitle(MediaItem mediaItem)
+        {
+            switch (mediaItem)
             {
-                Episode e => e.EpisodeMetadata.HeadOrNone()
-                    .Map(em => $"{em.Title} - s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00}")
-                    .IfNone("[unknown episode]"),
-                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]"),
-                _ => string.Empty
-            };
+                case Episode e:
+                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                    return e.EpisodeMetadata.HeadOrNone()
+                        .Map(em => $"{showTitle}s{e.Season.SeasonNumber:00}e{e.EpisodeNumber:00} - {em.Title}")
+                        .IfNone("[unknown episode]");
+                case Movie m:
+                    return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
+                case MusicVideo mv:
+                    return mv.MusicVideoMetadata.HeadOrNone().Map(mvm => $"{mvm.Artist} - {mvm.Title}")
+                        .IfNone("[unknown music video]");
+                default:
+                    return string.Empty;
+            }
+        }
 
         private static string GetDisplayDuration(MediaItem mediaItem)
         {
@@ -40,6 +50,7 @@ namespace ErsatzTV.Application.Playouts
             {
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
             };
 

ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs

@@ -57,11 +57,11 @@ namespace ErsatzTV.Application.Plex.Commands
             return allExisting;
         }
 
-        private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+        private Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
         {
             Option<PlexMediaSource> maybeExisting =
                 allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
-            await maybeExisting.Match(
+            return maybeExisting.Match(
                 existing =>
                 {
                     existing.Platform = server.Platform;
@@ -84,15 +84,5 @@ namespace ErsatzTV.Application.Plex.Commands
                     await _mediaSourceRepository.Add(server);
                 });
         }
-
-        private void MergeConnections(
-            List<PlexConnection> existing,
-            List<PlexConnection> incoming)
-        {
-            var toAdd = incoming.Filter(connection => existing.All(c => c.Uri != connection.Uri)).ToList();
-            var toRemove = existing.Filter(connection => incoming.All(c => c.Uri != connection.Uri)).ToList();
-            existing.AddRange(toAdd);
-            toRemove.ForEach(c => existing.Remove(c));
-        }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -16,5 +16,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MediaItemId,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+        bool? OfflineTail,
+        string CustomTitle) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
 }

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -13,5 +13,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MultipleCount { get; }
         TimeSpan? PlayoutDuration { get; }
         bool? OfflineTail { get; }
+        string CustomTitle { get; }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -100,7 +100,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
-                    MediaItemId = item.MediaItemId
+                    MediaItemId = item.MediaItemId,
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.One => new ProgramScheduleItemOne
                 {
@@ -109,7 +110,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     StartTime = item.StartTime,
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
-                    MediaItemId = item.MediaItemId
+                    MediaItemId = item.MediaItemId,
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.Multiple => new ProgramScheduleItemMultiple
                 {
@@ -119,7 +121,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MediaItemId = item.MediaItemId,
-                    Count = item.MultipleCount.GetValueOrDefault()
+                    Count = item.MultipleCount.GetValueOrDefault(),
+                    CustomTitle = item.CustomTitle
                 },
                 PlayoutMode.Duration => new ProgramScheduleItemDuration
                 {
@@ -130,7 +133,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     CollectionId = item.CollectionId,
                     MediaItemId = item.MediaItemId,
                     PlayoutDuration = item.PlayoutDuration.GetValueOrDefault(),
-                    OfflineTail = item.OfflineTail.GetValueOrDefault()
+                    OfflineTail = item.OfflineTail.GetValueOrDefault(),
+                    CustomTitle = item.CustomTitle
                 },
                 _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
             };

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -17,7 +17,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int? MediaItemId,
         int? MultipleCount,
         TimeSpan? PlayoutDuration,
-        bool? OfflineTail) : IProgramScheduleItemRequest;
+        bool? OfflineTail,
+        string CustomTitle) : IProgramScheduleItemRequest;
 
     public record ReplaceProgramScheduleItems
         (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -28,7 +28,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             _ => null
                         },
                         duration.PlayoutDuration,
-                        duration.OfflineTail),
+                        duration.OfflineTail,
+                        duration.CustomTitle),
                 ProgramScheduleItemFlood flood =>
                     new ProgramScheduleItemFloodViewModel(
                         flood.Id,
@@ -44,7 +45,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
-                        }),
+                        },
+                        flood.CustomTitle),
                 ProgramScheduleItemMultiple multiple =>
                     new ProgramScheduleItemMultipleViewModel(
                         multiple.Id,
@@ -61,7 +63,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
                         },
-                        multiple.Count),
+                        multiple.Count,
+                        multiple.CustomTitle),
                 ProgramScheduleItemOne one =>
                     new ProgramScheduleItemOneViewModel(
                         one.Id,
@@ -77,7 +80,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                             Show show => MediaItems.Mapper.ProjectToViewModel(show),
                             Season season => MediaItems.Mapper.ProjectToViewModel(season),
                             _ => null
-                        }),
+                        },
+                        one.CustomTitle),
                 _ => throw new NotSupportedException(
                     $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
             };

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -16,7 +16,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             MediaCollectionViewModel collection,
             NamedMediaItemViewModel mediaItem,
             TimeSpan playoutDuration,
-            bool offlineTail) : base(
+            bool offlineTail,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -24,7 +25,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Duration,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
             PlayoutDuration = playoutDuration;
             OfflineTail = offlineTail;

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -14,7 +14,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
-            NamedMediaItemViewModel mediaItem) : base(
+            NamedMediaItemViewModel mediaItem,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -22,7 +23,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Flood,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -15,7 +15,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
             NamedMediaItemViewModel mediaItem,
-            int count) : base(
+            int count,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -23,7 +24,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.Multiple,
             collectionType,
             collection,
-            mediaItem) =>
+            mediaItem,
+            customTitle) =>
             Count = count;
 
         public int Count { get; }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -14,7 +14,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             TimeSpan? startTime,
             ProgramScheduleItemCollectionType collectionType,
             MediaCollectionViewModel collection,
-            NamedMediaItemViewModel mediaItem) : base(
+            NamedMediaItemViewModel mediaItem,
+            string customTitle) : base(
             id,
             index,
             startType,
@@ -22,7 +23,8 @@ namespace ErsatzTV.Application.ProgramSchedules
             PlayoutMode.One,
             collectionType,
             collection,
-            mediaItem)
+            mediaItem,
+            customTitle)
         {
         }
     }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -13,7 +13,8 @@ namespace ErsatzTV.Application.ProgramSchedules
         PlayoutMode PlayoutMode,
         ProgramScheduleItemCollectionType CollectionType,
         MediaCollectionViewModel Collection,
-        NamedMediaItemViewModel MediaItem)
+        NamedMediaItemViewModel MediaItem,
+        string CustomTitle)
     {
         public string Name => CollectionType switch
         {

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.MediaCards;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexMusicVideos
+        (string Query, int PageNumber, int PageSize) : IRequest<MusicVideoCardResultsViewModel>;
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexMusicVideosHandler : IRequestHandler<QuerySearchIndexMusicVideos, MusicVideoCardResultsViewModel
+        >
+    {
+        private readonly IMusicVideoRepository _musicVideoRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexMusicVideosHandler(ISearchIndex searchIndex, IMusicVideoRepository musicVideoRepository)
+        {
+            _searchIndex = searchIndex;
+            _musicVideoRepository = musicVideoRepository;
+        }
+
+        public async Task<MusicVideoCardResultsViewModel> Handle(
+            QuerySearchIndexMusicVideos request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<MusicVideoCardViewModel> items = await _musicVideoRepository
+                .GetMusicVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new MusicVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -5,30 +5,38 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Application.Streaming.Queries
 {
     public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
     {
+        private readonly IConfigElementRepository _configElementRepository;
         private readonly FFmpegProcessService _ffmpegProcessService;
 
         public GetConcatProcessByChannelNumberHandler(
             IChannelRepository channelRepository,
             IConfigElementRepository configElementRepository,
             FFmpegProcessService ffmpegProcessService)
-            : base(channelRepository, configElementRepository) =>
+            : base(channelRepository, configElementRepository)
+        {
+            _configElementRepository = configElementRepository;
             _ffmpegProcessService = ffmpegProcessService;
+        }
 
-        protected override Task<Either<BaseError, Process>> GetProcess(
+        protected override async Task<Either<BaseError, Process>> GetProcess(
             GetConcatProcessByChannelNumber request,
             Channel channel,
-            string ffmpegPath) =>
-            Right<BaseError, Process>(
-                _ffmpegProcessService.ConcatChannel(
-                    ffmpegPath,
-                    channel,
-                    request.Scheme,
-                    request.Host)).AsTask();
+            string ffmpegPath)
+        {
+            bool saveReports = await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                .Map(result => result.IfNone(false));
+
+            return _ffmpegProcessService.ConcatChannel(
+                ffmpegPath,
+                saveReports,
+                channel,
+                request.Scheme,
+                request.Host);
+        }
     }
 }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -56,6 +56,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                     {
                         Movie m => m.MediaVersions.Head(),
                         Episode e => e.MediaVersions.Head(),
+                        MusicVideo mv => mv.MediaVersions.Head(),
                         _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                     };
 
@@ -153,6 +154,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             {
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
             };
 

ErsatzTV.CommandLine/Commands/FFmpegProfileCommand.cs

@@ -28,7 +28,7 @@ namespace ErsatzTV.CommandLine.Commands
         public string Name { get; set; }
 
         [CommandOption("thread-count", Description = "The number of threads")]
-        public int ThreadCount { get; set; } = 4;
+        public int ThreadCount { get; set; } = 0;
 
         [CommandOption("transcode", Description = "Whether to transcode all media")]
         public bool Transcode { get; set; } = true;

ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj

@@ -2,13 +2,22 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="FluentAssertions" Version="5.10.3" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Moq" Version="4.16.1" />
       <PackageReference Include="NUnit" Version="3.13.1" />
       <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -163,9 +163,9 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void ShouldNot_SetScaledSize_When_NotNormalizingResolution_ForTransportStream()
+            public void ShouldNot_SetScaledSize_When_NotNormalizingVideo_ForTransportStream()
             {
-                FFmpegProfile ffmpegProfile = TestProfile() with { NormalizeResolution = false };
+                FFmpegProfile ffmpegProfile = TestProfile() with { NormalizeVideo = false };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                     StreamingMode.TransportStream,
@@ -184,7 +184,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -208,7 +208,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -232,7 +232,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -257,7 +257,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -282,7 +282,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -303,11 +303,11 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_NotPadToDesiredResolution_When_NotNormalizingResolution()
+            public void Should_NotPadToDesiredResolution_When_NotNormalizingVideo()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeResolution = false,
+                    NormalizeVideo = false,
                     Resolution = new Resolution { Width = 1920, Height = 1080 }
                 };
 
@@ -332,9 +332,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = false,
                     VideoCodec = "testCodec"
                 };
 
@@ -357,13 +356,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
             [Test]
             public void
-                Should_SetDesiredVideoCodec_When_ContentIsCorrectSize_And_NormalizingWrongCodec_ForTransportStream()
+                Should_SetDesiredVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = true,
                     VideoCodec = "testCodec"
                 };
 
@@ -387,13 +385,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
             [Test]
             public void
-                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NormalizingWrongCodec_ForHttpLiveStreaming()
+                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForHttpLiveStreaming()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = true,
                     VideoCodec = "testCodec"
                 };
 
@@ -420,9 +417,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = true,
                     VideoCodec = "libx264"
                 };
 
@@ -446,13 +442,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
             [Test]
             public void
-                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingWrongCodec_ForTransportStream()
+                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingVideo_ForTransportStream()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = false,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = false,
                     VideoCodec = "libx264"
                 };
 
@@ -479,9 +474,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = false,
                     VideoBitrate = 2525
                 };
 
@@ -503,13 +497,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetVideoBitrate_When_ContentIsCorrectSize_And_NormalizingWrongCodec_ForTransportStream()
+            public void Should_SetVideoBitrate_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = true,
                     VideoBitrate = 2525
                 };
 
@@ -536,9 +529,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = false,
                     VideoBufferSize = 2525
                 };
 
@@ -561,13 +553,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
             [Test]
             public void
-                Should_SetVideoBufferSize_When_ContentIsCorrectSize_And_NormalizingWrongCodec_ForTransportStream()
+                Should_SetVideoBufferSize_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
             {
                 var ffmpegProfile = new FFmpegProfile
                 {
-                    NormalizeResolution = true,
+                    NormalizeVideo = true,
                     Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    NormalizeVideoCodec = true,
                     VideoBufferSize = 2525
                 };
 
@@ -590,11 +581,11 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetCopyAudioCodec_When_CorrectCodec_ForTransportStream()
+            public void Should_SetDesiredAudioCodec_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
+                    NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
 
@@ -609,15 +600,15 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
-                actual.AudioCodec.Should().Be("copy");
+                actual.AudioCodec.Should().Be("aac");
             }
 
             [Test]
-            public void Should_SetCopyAudioCodec_When_NotNormalizingWrongCodec_ForTransportStream()
+            public void Should_SetCopyAudioCodec_When_NotNormalizingAudio_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = false,
+                    NormalizeAudio = false,
                     AudioCodec = "aac"
                 };
 
@@ -636,11 +627,11 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetDesiredAudioCodec_When_NormalizingWrongCodec_ForTransportStream()
+            public void Should_SetDesiredAudioCodec_When_NormalizingAudio_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
+                    NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
 
@@ -659,11 +650,11 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetCopyAudioCodec_When_NormalizingWrongCodec_ForHttpLiveStreaming()
+            public void Should_SetCopyAudioCodec_When_NormalizingAudio_ForHttpLiveStreaming()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
+                    NormalizeAudio = true,
                     AudioCodec = "aac"
                 };
 
@@ -682,12 +673,13 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetAudioBitrate_When_NormalizingWrongCodec_ForTransportStream()
+            public void Should_SetAudioBitrate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
-                    AudioBitrate = 2424
+                    NormalizeAudio = true,
+                    AudioBitrate = 2424,
+                    AudioCodec = "ac3"
                 };
 
                 var version = new MediaVersion();
@@ -705,12 +697,13 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetAudioBufferSize_When_NormalizingWrongCodec_ForTransportStream()
+            public void Should_SetAudioBufferSize_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
-                    AudioBufferSize = 2424
+                    NormalizeAudio = true,
+                    AudioBufferSize = 2424,
+                    AudioCodec = "ac3"
                 };
 
                 var version = new MediaVersion();
@@ -728,11 +721,10 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void ShouldNot_SetAudioChannels_When_CorrectCodec_ForTransportStream()
+            public void Should_SetAudioChannels_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
                     NormalizeAudio = true,
                     AudioCodec = "ac3",
                     AudioChannels = 6
@@ -749,15 +741,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
-                actual.AudioChannels.IsNone.Should().BeTrue();
+                actual.AudioChannels.IfNone(0).Should().Be(6);
             }
 
             [Test]
-            public void ShouldNot_SetAudioSampleRate_When_CorrectCodec_ForTransportStream()
+            public void Should_SetAudioSampleRate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
                     NormalizeAudio = true,
                     AudioCodec = "ac3",
                     AudioSampleRate = 48
@@ -774,15 +765,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
-                actual.AudioSampleRate.IsNone.Should().BeTrue();
+                actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
 
             [Test]
-            public void Should_SetAudioChannels_When_NormalizingWrongCodecAndAudio_ForTransportStream()
+            public void Should_SetAudioChannels_When_NormalizingAudio_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
                     NormalizeAudio = true,
                     AudioChannels = 6
                 };
@@ -802,11 +792,10 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void Should_SetAudioSampleRate_When_NormalizingWrongCodecAndAudio_ForTransportStream()
+            public void Should_SetAudioSampleRate_When_NormalizingAudio_ForTransportStream()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with
                 {
-                    NormalizeAudioCodec = true,
                     NormalizeAudio = true,
                     AudioSampleRate = 48
                 };
@@ -824,6 +813,76 @@ namespace ErsatzTV.Core.Tests.FFmpeg
 
                 actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
+
+            [Test]
+            public void Should_SetAudioDuration_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+            {
+                FFmpegProfile ffmpegProfile = TestProfile() with
+                {
+                    NormalizeAudio = true,
+                    AudioSampleRate = 48,
+                    AudioCodec = "ac3"
+                };
+
+                var version = new MediaVersion { Duration = TimeSpan.FromMinutes(2) };
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                actual.AudioDuration.IfNone(TimeSpan.MinValue).Should().Be(TimeSpan.FromMinutes(2));
+            }
+
+            [Test]
+            public void Should_SetNormalizeLoudness_When_NormalizingAudio_ForTransportStream()
+            {
+                FFmpegProfile ffmpegProfile = TestProfile() with
+                {
+                    NormalizeAudio = true,
+                    NormalizeLoudness = true
+                };
+
+                var version = new MediaVersion();
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                actual.NormalizeLoudness.Should().BeTrue();
+            }
+
+            [Test]
+            public void Should_NotSetNormalizeLoudness_When_NotNormalizingAudio_ForTransportStream()
+            {
+                FFmpegProfile ffmpegProfile = TestProfile() with
+                {
+                    NormalizeAudio = false,
+                    NormalizeLoudness = true
+                };
+
+                var version = new MediaVersion();
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream(),
+                    new MediaStream { Codec = "ac3" },
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                actual.NormalizeLoudness.Should().BeFalse();
+            }
         }
 
         [TestFixture]

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -56,8 +56,8 @@ namespace ErsatzTV.Core.Tests.Fakes
 
         public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
 
-        public Unit CopyFile(string source, string destination) =>
-            Unit.Default;
+        public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
+            Task.FromResult(Right<BaseError, Unit>(Unit.Default));
 
         private static List<DirectoryInfo> Split(DirectoryInfo path)
         {

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -57,7 +57,7 @@ namespace ErsatzTV.Core.Tests.Metadata
                     .Returns<string, MediaItem>((_, _) => Right<BaseError, bool>(true).AsTask());
 
                 // fallback metadata adds metadata to a movie, so we need to replicate that here
-                _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<MediaItem>()))
+                _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<Movie>()))
                     .Returns(
                         (MediaItem mediaItem) =>
                         {

ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs

@@ -610,6 +610,190 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[5].MediaItemId.Should().Be(4);
         }
 
+        [Test]
+        public async Task Alternating_MultipleContent_Should_Maintain_Counts()
+        {
+            var collectionOne = new Collection
+            {
+                Id = 1,
+                Name = "Multiple Items 1",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+                }
+            };
+
+            var collectionTwo = new Collection
+            {
+                Id = 2,
+                Name = "Multiple Items 2",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+                }
+            };
+
+            var fakeRepository = new FakeMediaCollectionRepository(
+                Map(
+                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                    (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
+
+            var items = new List<ProgramScheduleItem>
+            {
+                new ProgramScheduleItemMultiple
+                {
+                    Id = 1,
+                    Index = 1,
+                    Collection = collectionOne,
+                    CollectionId = collectionOne.Id,
+                    StartTime = null,
+                    Count = 3
+                },
+                new ProgramScheduleItemMultiple
+                {
+                    Id = 2,
+                    Index = 2,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id,
+                    StartTime = null,
+                    Count = 3
+                }
+            };
+
+            var playout = new Playout
+            {
+                ProgramSchedule = new ProgramSchedule
+                {
+                    Items = items,
+                    MediaCollectionPlaybackOrder = PlaybackOrder.Chronological
+                },
+                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+                Anchor = new PlayoutAnchor
+                {
+                    NextStart = HoursAfterMidnight(1).UtcDateTime,
+                    NextScheduleItem = items[0],
+                    NextScheduleItemId = 1,
+                    MultipleRemaining = 2
+                }
+            };
+
+            var televisionRepo = new FakeTelevisionRepository();
+            var builder = new PlayoutBuilder(fakeRepository, televisionRepo, _logger);
+
+            DateTimeOffset start = HoursAfterMidnight(0);
+            DateTimeOffset finish = start + TimeSpan.FromHours(5);
+
+            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+            result.Items.Count.Should().Be(4);
+
+            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+            result.Items[0].MediaItemId.Should().Be(1);
+            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+            result.Items[1].MediaItemId.Should().Be(1);
+
+            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+            result.Items[2].MediaItemId.Should().Be(2);
+            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+            result.Items[3].MediaItemId.Should().Be(2);
+
+            result.Anchor.NextScheduleItem.Should().Be(items[1]);
+            result.Anchor.MultipleRemaining.Should().Be(1);
+        }
+
+        [Test]
+        public async Task Alternating_Duration_Should_Maintain_Duration()
+        {
+            var collectionOne = new Collection
+            {
+                Id = 1,
+                Name = "Duration Items 1",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+                }
+            };
+
+            var collectionTwo = new Collection
+            {
+                Id = 2,
+                Name = "Duration Items 2",
+                MediaItems = new List<MediaItem>
+                {
+                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+                }
+            };
+
+            var fakeRepository = new FakeMediaCollectionRepository(
+                Map(
+                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                    (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
+
+            var items = new List<ProgramScheduleItem>
+            {
+                new ProgramScheduleItemDuration
+                {
+                    Id = 1,
+                    Index = 1,
+                    Collection = collectionOne,
+                    CollectionId = collectionOne.Id,
+                    StartTime = null,
+                    PlayoutDuration = TimeSpan.FromHours(3),
+                    OfflineTail = false
+                },
+                new ProgramScheduleItemDuration
+                {
+                    Id = 2,
+                    Index = 2,
+                    Collection = collectionTwo,
+                    CollectionId = collectionTwo.Id,
+                    StartTime = null,
+                    PlayoutDuration = TimeSpan.FromHours(3),
+                    OfflineTail = false
+                }
+            };
+
+            var playout = new Playout
+            {
+                ProgramSchedule = new ProgramSchedule
+                {
+                    Items = items,
+                    MediaCollectionPlaybackOrder = PlaybackOrder.Chronological
+                },
+                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+                Anchor = new PlayoutAnchor
+                {
+                    NextStart = HoursAfterMidnight(1).UtcDateTime,
+                    NextScheduleItem = items[0],
+                    NextScheduleItemId = 1,
+                    DurationFinish = HoursAfterMidnight(3).UtcDateTime
+                }
+            };
+
+            var televisionRepo = new FakeTelevisionRepository();
+            var builder = new PlayoutBuilder(fakeRepository, televisionRepo, _logger);
+
+            DateTimeOffset start = HoursAfterMidnight(0);
+            DateTimeOffset finish = start + TimeSpan.FromHours(5);
+
+            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+            result.Items.Count.Should().Be(4);
+
+            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+            result.Items[0].MediaItemId.Should().Be(1);
+            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+            result.Items[1].MediaItemId.Should().Be(1);
+
+            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+            result.Items[2].MediaItemId.Should().Be(2);
+            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+            result.Items[3].MediaItemId.Should().Be(2);
+
+            result.Anchor.NextScheduleItem.Should().Be(items[1]);
+            result.Anchor.DurationFinish.Should().Be(HoursAfterMidnight(6).UtcDateTime);
+        }
+
         private static DateTimeOffset HoursAfterMidnight(int hours)
         {
             DateTimeOffset now = DateTimeOffset.Now;

ErsatzTV.Core/Domain/FFmpegProfile.cs

@@ -9,16 +9,15 @@
         public HardwareAccelerationKind HardwareAcceleration { get; set; }
         public int ResolutionId { get; set; }
         public Resolution Resolution { get; set; }
-        public bool NormalizeResolution { get; set; }
         public string VideoCodec { get; set; }
-        public bool NormalizeVideoCodec { get; set; }
+        public bool NormalizeVideo { get; set; }
         public int VideoBitrate { get; set; }
         public int VideoBufferSize { get; set; }
+        public string FrameRate { get; set; }
         public string AudioCodec { get; set; }
-        public bool NormalizeAudioCodec { get; set; }
         public int AudioBitrate { get; set; }
         public int AudioBufferSize { get; set; }
-        public int AudioVolume { get; set; }
+        public bool NormalizeLoudness { get; set; }
         public int AudioChannels { get; set; }
         public int AudioSampleRate { get; set; }
         public bool NormalizeAudio { get; set; }
@@ -27,7 +26,7 @@
             new()
             {
                 Name = name,
-                ThreadCount = 4,
+                ThreadCount = 0,
                 Transcode = true,
                 ResolutionId = resolution.Id,
                 Resolution = resolution,
@@ -37,12 +36,11 @@
                 VideoBufferSize = 4000,
                 AudioBitrate = 192,
                 AudioBufferSize = 384,
-                AudioVolume = 100,
+                NormalizeLoudness = true,
                 AudioChannels = 2,
                 AudioSampleRate = 48,
-                NormalizeResolution = true,
-                NormalizeVideoCodec = true,
-                NormalizeAudioCodec = true,
+                NormalizeVideo = true,
+                FrameRate = "24",
                 NormalizeAudio = true
             };
     }

ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs

@@ -3,6 +3,7 @@
     public enum LibraryMediaKind
     {
         Movies = 1,
-        Shows = 2
+        Shows = 2,
+        MusicVideos = 3
     }
 }

ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs

@@ -13,16 +13,6 @@ namespace ErsatzTV.Core.Domain
         public TimeSpan Duration { get; set; }
         public string SampleAspectRatio { get; set; }
         public string DisplayAspectRatio { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string VideoCodec { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string VideoProfile { get; set; }
-
-        [Obsolete("Use MediaSource instead")]
-        public string AudioCodec { get; set; }
-
         public VideoScanKind VideoScanKind { get; set; }
         public DateTime DateAdded { get; set; }
         public DateTime DateUpdated { get; set; }

ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class MusicVideo : MediaItem
+    {
+        public List<MusicVideoMetadata> MusicVideoMetadata { get; set; }
+        public List<MediaVersion> MediaVersions { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class MusicVideoMetadata : Metadata
+    {
+        public string Album { get; set; }
+        public string Plot { get; set; }
+        public string Artist { get; set; }
+        public int MusicVideoId { get; set; }
+        public MusicVideo MusicVideo { get; set; }
+    }
+}

ErsatzTV.Core/Domain/PlayoutAnchor.cs

@@ -1,4 +1,6 @@
 using System;
+using LanguageExt;
+using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Domain
 {
@@ -9,7 +11,13 @@ namespace ErsatzTV.Core.Domain
         public ProgramScheduleItem NextScheduleItem { get; set; }
 
         public DateTime NextStart { get; set; }
+        public int? MultipleRemaining { get; set; }
+        public DateTime? DurationFinish { get; set; }
 
         public DateTimeOffset NextStartOffset => new DateTimeOffset(NextStart, TimeSpan.Zero).ToLocalTime();
+
+        public Option<DateTimeOffset> DurationFinishOffset =>
+            Optional(DurationFinish)
+                .Map(durationFinish => new DateTimeOffset(durationFinish, TimeSpan.Zero).ToLocalTime());
     }
 }

ErsatzTV.Core/Domain/PlayoutItem.cs

@@ -9,6 +9,8 @@ namespace ErsatzTV.Core.Domain
         public MediaItem MediaItem { get; set; }
         public DateTime Start { get; set; }
         public DateTime Finish { get; set; }
+        public string CustomTitle { get; set; }
+        public bool CustomGroup { get; set; }
         public int PlayoutId { get; set; }
         public Playout Playout { get; set; }
 

ErsatzTV.Core/Domain/ProgramScheduleItem.cs

@@ -9,6 +9,7 @@ namespace ErsatzTV.Core.Domain
         public StartType StartType => StartTime.HasValue ? StartType.Fixed : StartType.Dynamic;
         public TimeSpan? StartTime { get; set; }
         public ProgramScheduleItemCollectionType CollectionType { get; set; }
+        public string CustomTitle { get; set; }
         public int ProgramScheduleId { get; set; }
         public ProgramSchedule ProgramSchedule { get; set; }
         public int? CollectionId { get; set; }

ErsatzTV.Core/ErsatzTV.Core.csproj

@@ -2,12 +2,21 @@
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0" />
       <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />

ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs

@@ -13,8 +13,10 @@ namespace ErsatzTV.Core.FFmpeg
     {
         private Option<TimeSpan> _audioDuration = None;
         private bool _deinterlace;
+        private Option<string> _frameRate = None;
         private Option<HardwareAccelerationKind> _hardwareAccelerationKind = None;
         private string _inputCodec;
+        private bool _normalizeLoudness;
         private Option<IDisplaySize> _padToSize = None;
         private Option<IDisplaySize> _scaleToSize = None;
 
@@ -48,12 +50,24 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
+        public FFmpegComplexFilterBuilder WithNormalizeLoudness(bool normalizeLoudness)
+        {
+            _normalizeLoudness = normalizeLoudness;
+            return this;
+        }
+
         public FFmpegComplexFilterBuilder WithInputCodec(string codec)
         {
             _inputCodec = codec;
             return this;
         }
 
+        public FFmpegComplexFilterBuilder WithFrameRate(Option<string> frameRate)
+        {
+            _frameRate = frameRate;
+            return this;
+        }
+
         public Option<FFmpegComplexFilter> Build(int videoStreamIndex, int audioStreamIndex)
         {
             var complexFilter = new StringBuilder();
@@ -70,22 +84,22 @@ namespace ErsatzTV.Core.FFmpeg
                 _ => false
             };
 
-            _audioDuration.IfSome(
-                audioDuration =>
-                {
-                    complexFilter.Append($"[{audioLabel}]");
-                    complexFilter.Append($"apad=whole_dur={audioDuration.TotalMilliseconds}ms");
-                    audioLabel = "[a]";
-                    complexFilter.Append(audioLabel);
-                });
+            var audioFilterQueue = new List<string>();
+            var videoFilterQueue = new List<string>();
 
-            var filterQueue = new List<string>();
+            if (_normalizeLoudness)
+            {
+                audioFilterQueue.Add("loudnorm=I=-16:TP=-1.5:LRA=11");
+            }
+
+            _audioDuration.IfSome(
+                audioDuration => audioFilterQueue.Add($"apad=whole_dur={audioDuration.TotalMilliseconds}ms"));
 
             bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None && !isHardwareDecode &&
                                        (_deinterlace || _scaleToSize.IsSome);
             if (usesHardwareFilters)
             {
-                filterQueue.Add("hwupload");
+                videoFilterQueue.Add("hwupload");
             }
 
             if (_deinterlace)
@@ -100,10 +114,12 @@ namespace ErsatzTV.Core.FFmpeg
 
                 if (!string.IsNullOrWhiteSpace(filter))
                 {
-                    filterQueue.Add(filter);
+                    videoFilterQueue.Add(filter);
                 }
             }
 
+            _frameRate.IfSome(frameRate => videoFilterQueue.Add($"fps=fps={frameRate}"));
+
             _scaleToSize.IfSome(
                 size =>
                 {
@@ -117,7 +133,7 @@ namespace ErsatzTV.Core.FFmpeg
 
                     if (!string.IsNullOrWhiteSpace(filter))
                     {
-                        filterQueue.Add(filter);
+                        videoFilterQueue.Add(filter);
                     }
                 });
 
@@ -125,19 +141,19 @@ namespace ErsatzTV.Core.FFmpeg
             {
                 if (acceleration != HardwareAccelerationKind.None && (isHardwareDecode || usesHardwareFilters))
                 {
-                    filterQueue.Add("hwdownload");
+                    videoFilterQueue.Add("hwdownload");
                     string format = acceleration switch
                     {
                         HardwareAccelerationKind.Vaapi => "format=nv12|vaapi",
                         _ => "format=nv12"
                     };
-                    filterQueue.Add(format);
+                    videoFilterQueue.Add(format);
                 }
 
-                filterQueue.Add("setsar=1");
+                videoFilterQueue.Add("setsar=1");
             }
 
-            _padToSize.IfSome(size => filterQueue.Add($"pad={size.Width}:{size.Height}:(ow-iw)/2:(oh-ih)/2"));
+            _padToSize.IfSome(size => videoFilterQueue.Add($"pad={size.Width}:{size.Height}:(ow-iw)/2:(oh-ih)/2"));
 
             if ((_scaleToSize.IsSome || _padToSize.IsSome) && acceleration != HardwareAccelerationKind.None)
             {
@@ -146,19 +162,27 @@ namespace ErsatzTV.Core.FFmpeg
                     HardwareAccelerationKind.Qsv => "hwupload=extra_hw_frames=64",
                     _ => "hwupload"
                 };
-                filterQueue.Add(upload);
+                videoFilterQueue.Add(upload);
             }
 
-            if (filterQueue.Any())
+            bool hasAudioFilters = audioFilterQueue.Any();
+            if (hasAudioFilters)
             {
-                // TODO: any audio filter
-                if (_audioDuration.IsSome)
+                complexFilter.Append($"[{audioLabel}]");
+                complexFilter.Append(string.Join(",", audioFilterQueue));
+                audioLabel = "[a]";
+                complexFilter.Append(audioLabel);
+            }
+
+            if (videoFilterQueue.Any())
+            {
+                if (hasAudioFilters)
                 {
                     complexFilter.Append(';');
                 }
 
                 complexFilter.Append($"[{videoLabel}]");
-                complexFilter.Append(string.Join(",", filterQueue));
+                complexFilter.Append(string.Join(",", videoFilterQueue));
                 videoLabel = "[v]";
                 complexFilter.Append(videoLabel);
             }

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs

@@ -16,7 +16,6 @@ namespace ErsatzTV.Core.FFmpeg
         public Option<TimeSpan> StreamSeek { get; set; }
         public Option<IDisplaySize> ScaledSize { get; set; }
         public bool PadToDesiredResolution { get; set; }
-        public string ScalingAlgorithm => "fast_bilinear"; // TODO: from config, add tests
         public string VideoCodec { get; set; }
         public Option<int> VideoBitrate { get; set; }
         public Option<int> VideoBufferSize { get; set; }
@@ -27,5 +26,8 @@ namespace ErsatzTV.Core.FFmpeg
         public Option<TimeSpan> AudioDuration { get; set; }
         public string AudioCodec { get; set; }
         public bool Deinterlace { get; set; }
+        public Option<string> FrameRate { get; set; }
+        public Option<int> VideoTrackTimeScale { get; set; }
+        public bool NormalizeLoudness { get; set; }
     }
 }

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs

@@ -81,11 +81,20 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     IDisplaySize sizeAfterScaling = result.ScaledSize.IfNone(version);
-                    if (ffmpegProfile.NormalizeResolution && !sizeAfterScaling.IsSameSizeAs(ffmpegProfile.Resolution))
+                    if (ffmpegProfile.NormalizeVideo && !sizeAfterScaling.IsSameSizeAs(ffmpegProfile.Resolution))
                     {
                         result.PadToDesiredResolution = true;
                     }
 
+                    if (ffmpegProfile.NormalizeVideo)
+                    {
+                        result.FrameRate = string.IsNullOrWhiteSpace(ffmpegProfile.FrameRate)
+                            ? None
+                            : Some(ffmpegProfile.FrameRate);
+
+                        result.VideoTrackTimeScale = 90000;
+                    }
+
                     if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
                         NeedToNormalizeVideoCodec(ffmpegProfile, videoStream))
                     {
@@ -98,22 +107,20 @@ namespace ErsatzTV.Core.FFmpeg
                         result.VideoCodec = "copy";
                     }
 
-                    if (NeedToNormalizeAudioCodec(ffmpegProfile, audioStream))
+                    if (ffmpegProfile.NormalizeAudio)
                     {
                         result.AudioCodec = ffmpegProfile.AudioCodec;
                         result.AudioBitrate = ffmpegProfile.AudioBitrate;
                         result.AudioBufferSize = ffmpegProfile.AudioBufferSize;
 
-                        if (ffmpegProfile.NormalizeAudio)
+                        if (audioStream.Channels != ffmpegProfile.AudioChannels)
                         {
-                            if (audioStream.Channels != ffmpegProfile.AudioChannels)
-                            {
-                                result.AudioChannels = ffmpegProfile.AudioChannels;
-                            }
-
-                            result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
-                            result.AudioDuration = version.Duration;
+                            result.AudioChannels = ffmpegProfile.AudioChannels;
                         }
+
+                        result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
+                        result.AudioDuration = version.Duration;
+                        result.NormalizeLoudness = ffmpegProfile.NormalizeLoudness;
                     }
                     else
                     {
@@ -141,7 +148,7 @@ namespace ErsatzTV.Core.FFmpeg
             };
 
         private static bool NeedToScale(FFmpegProfile ffmpegProfile, MediaVersion version) =>
-            ffmpegProfile.NormalizeResolution &&
+            ffmpegProfile.NormalizeVideo &&
             IsIncorrectSize(ffmpegProfile.Resolution, version) ||
             IsTooLarge(ffmpegProfile.Resolution, version) ||
             IsOddSize(version);
@@ -159,10 +166,7 @@ namespace ErsatzTV.Core.FFmpeg
             version.Height % 2 == 1 || version.Width % 2 == 1;
 
         private static bool NeedToNormalizeVideoCodec(FFmpegProfile ffmpegProfile, MediaStream videoStream) =>
-            ffmpegProfile.NormalizeVideoCodec && ffmpegProfile.VideoCodec != videoStream.Codec;
-
-        private static bool NeedToNormalizeAudioCodec(FFmpegProfile ffmpegProfile, MediaStream audioStream) =>
-            ffmpegProfile.NormalizeAudioCodec && ffmpegProfile.AudioCodec != audioStream.Codec;
+            ffmpegProfile.NormalizeVideo && ffmpegProfile.VideoCodec != videoStream.Codec;
 
         private static IDisplaySize CalculateScaledSize(FFmpegProfile ffmpegProfile, MediaVersion version)
         {

ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs

@@ -42,6 +42,7 @@ namespace ErsatzTV.Core.FFmpeg
         private readonly string _ffmpegPath;
         private readonly bool _saveReports;
         private FFmpegComplexFilterBuilder _complexFilterBuilder = new();
+        private bool _isConcat;
 
         public FFmpegProcessBuilder(string ffmpegPath, bool saveReports)
         {
@@ -186,6 +187,8 @@ namespace ErsatzTV.Core.FFmpeg
 
         public FFmpegProcessBuilder WithConcat(string concatPlaylist)
         {
+            _isConcat = true;
+
             var arguments = new List<string>
             {
                 "-f", "concat",
@@ -193,8 +196,6 @@ namespace ErsatzTV.Core.FFmpeg
                 "-protocol_whitelist", "file,http,tcp,https,tcp,tls",
                 "-probesize", "32",
                 "-i", concatPlaylist,
-                "-map", "0:v",
-                "-map", "0:a",
                 "-c", "copy",
                 "-muxdelay", "0",
                 "-muxpreload", "0"
@@ -228,7 +229,7 @@ namespace ErsatzTV.Core.FFmpeg
             const string X = "x=(w-text_w)/2";
             const string Y = "y=(h-text_h)/3*2";
 
-            string fontSize = text.Length > 60 ? "fontsize=40" : "fontsize=60";
+            string fontSize = text.Length > 80 ? "fontsize=30" : text.Length > 60 ? "fontsize=40" : "fontsize=60";
 
             return WithFilterComplex(
                 $"[0:0]scale={desiredResolution.Width}:{desiredResolution.Height},drawtext={FONT_FILE}:{fontSize}:{FONT_COLOR}:{X}:{Y}:text='{text}'[v]",
@@ -323,6 +324,29 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
+        public FFmpegProcessBuilder WithNormalizeLoudness(bool normalizeLoudness)
+        {
+            _complexFilterBuilder = _complexFilterBuilder.WithNormalizeLoudness(normalizeLoudness);
+            return this;
+        }
+
+        public FFmpegProcessBuilder WithFrameRate(Option<string> frameRate)
+        {
+            _complexFilterBuilder = _complexFilterBuilder.WithFrameRate(frameRate);
+            return this;
+        }
+
+        public FFmpegProcessBuilder WithVideoTrackTimeScale(Option<int> videoTrackTimeScale)
+        {
+            videoTrackTimeScale.IfSome(
+                timeScale =>
+                {
+                    _arguments.Add("-video_track_timescale");
+                    _arguments.Add($"{timeScale}");
+                });
+            return this;
+        }
+
         public FFmpegProcessBuilder WithDeinterlace(bool deinterlace)
         {
             _complexFilterBuilder = _complexFilterBuilder.WithDeinterlace(deinterlace);
@@ -331,8 +355,8 @@ namespace ErsatzTV.Core.FFmpeg
 
         public FFmpegProcessBuilder WithFilterComplex(int videoStreamIndex, int audioStreamIndex)
         {
-            var videoLabel = $"0:v:{videoStreamIndex}";
-            var audioLabel = $"0:a:{audioStreamIndex}";
+            var videoLabel = $"0:{videoStreamIndex}";
+            var audioLabel = $"0:{audioStreamIndex}";
 
             Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(videoStreamIndex, audioStreamIndex);
             maybeFilter.IfSome(
@@ -373,10 +397,13 @@ namespace ErsatzTV.Core.FFmpeg
 
             if (_saveReports)
             {
-                string fileName = Path.Combine(FileSystemLayout.FFmpegReportsFolder, "%p-%t.log");
+                string fileName = _isConcat
+                    ? Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-concat.log")
+                    : Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-transcode.log");
                 startInfo.EnvironmentVariables.Add("FFREPORT", $"file={fileName}:level=32");
             }
 
+            startInfo.ArgumentList.Add("-nostdin");
             foreach (string argument in _arguments)
             {
                 startInfo.ArgumentList.Add(argument);

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -48,7 +48,11 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
                 .WithSeek(playbackSettings.StreamSeek)
-                .WithInputCodec(path, playbackSettings.HardwareAcceleration, videoStream.Codec);
+                .WithInputCodec(path, playbackSettings.HardwareAcceleration, videoStream.Codec)
+                .WithFrameRate(playbackSettings.FrameRate)
+                .WithVideoTrackTimeScale(playbackSettings.VideoTrackTimeScale)
+                .WithAlignedAudio(playbackSettings.AudioDuration)
+                .WithNormalizeLoudness(playbackSettings.NormalizeLoudness);
 
             playbackSettings.ScaledSize.Match(
                 scaledSize =>
@@ -63,7 +67,6 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     builder = builder
-                        .WithAlignedAudio(playbackSettings.AudioDuration)
                         .WithFilterComplex(videoStream.Index, audioStream.Index);
                 },
                 () =>
@@ -73,7 +76,6 @@ namespace ErsatzTV.Core.FFmpeg
                         builder = builder
                             .WithDeinterlace(playbackSettings.Deinterlace)
                             .WithBlackBars(channel.FFmpegProfile.Resolution)
-                            .WithAlignedAudio(playbackSettings.AudioDuration)
                             .WithFilterComplex(videoStream.Index, audioStream.Index);
                     }
                     else if (playbackSettings.Deinterlace)
@@ -85,7 +87,6 @@ namespace ErsatzTV.Core.FFmpeg
                     else
                     {
                         builder = builder
-                            .WithAlignedAudio(playbackSettings.AudioDuration)
                             .WithFilterComplex(videoStream.Index, audioStream.Index);
                     }
                 });
@@ -124,11 +125,11 @@ namespace ErsatzTV.Core.FFmpeg
             return builder.WithPipe().Build();
         }
 
-        public Process ConcatChannel(string ffmpegPath, Channel channel, string scheme, string host)
+        public Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
         {
             FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
 
-            return new FFmpegProcessBuilder(ffmpegPath, false)
+            return new FFmpegProcessBuilder(ffmpegPath, saveReports)
                 .WithThreads(1)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)

ErsatzTV.Core/Interfaces/Images/IImageCache.cs

@@ -8,6 +8,6 @@ namespace ErsatzTV.Core.Interfaces.Images
     {
         Task<Either<BaseError, byte[]>> ResizeImage(byte[] imageBuffer, int height);
         Task<Either<BaseError, string>> SaveArtworkToCache(byte[] imageBuffer, ArtworkKind artworkKind);
-        string CopyArtworkToCache(string path, ArtworkKind artworkKind);
+        Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs

@@ -15,6 +15,6 @@ namespace ErsatzTV.Core.Interfaces.Metadata
         IEnumerable<string> ListFiles(string folder);
         bool FileExists(string path);
         Task<byte[]> ReadAllBytes(string path);
-        Unit CopyFile(string source, string destination);
+        Task<Either<BaseError, Unit>> CopyFile(string source, string destination);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs

@@ -1,14 +1,19 @@
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Metadata
 {
     public interface ILocalMetadataProvider
     {
         Task<ShowMetadata> GetMetadataForShow(string showFolder);
-        Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path);
-        Task<bool> RefreshSidecarMetadata(Show televisionShow, string showFolder);
-        Task<bool> RefreshFallbackMetadata(MediaItem mediaItem);
+        Task<Option<MusicVideoMetadata>> GetMetadataForMusicVideo(string filePath);
+        Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName);
+        Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName);
+        Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName);
+        Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName);
+        Task<bool> RefreshFallbackMetadata(Movie movie);
+        Task<bool> RefreshFallbackMetadata(Episode episode);
         Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
     }
 }

ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Metadata
+{
+    public interface IMusicVideoFolderScanner
+    {
+        Task<Either<BaseError, Unit>> ScanFolder(LibraryPath libraryPath, string ffprobePath, DateTimeOffset lastScan);
+    }
+}

ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Interfaces.Repositories
+{
+    public interface IMusicVideoRepository
+    {
+        Task<Option<MusicVideo>> GetByMetadata(LibraryPath libraryPath, MusicVideoMetadata metadata);
+
+        Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> Add(
+            LibraryPath libraryPath,
+            string filePath,
+            MusicVideoMetadata metadata);
+
+        Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath);
+        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+        Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre);
+        Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag);
+        Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio);
+        Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids);
+        Task<Option<MusicVideo>> GetMusicVideo(int musicVideoId);
+    }
+}

ErsatzTV.Core/Iptv/ChannelGuide.cs

@@ -57,49 +57,36 @@ namespace ErsatzTV.Core.Iptv
 
             foreach (Channel channel in _channels.OrderBy(c => c.Number))
             {
-                foreach (PlayoutItem playoutItem in channel.Playouts.Collect(p => p.Items).OrderBy(i => i.Start))
+                var sorted = channel.Playouts.Collect(p => p.Items).OrderBy(x => x.Start).ToList();
+                var i = 0;
+                while (i < sorted.Count)
                 {
-                    string start = playoutItem.StartOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
-                    string stop = playoutItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
+                    PlayoutItem startItem = sorted[i];
+                    bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
 
-                    string title = playoutItem.MediaItem switch
+                    int finishIndex = i;
+                    while (hasCustomTitle && finishIndex + 1 < sorted.Count && sorted[finishIndex + 1].CustomGroup)
                     {
-                        Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
-                            .IfNone("[unknown movie]"),
-                        Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
-                            .IfNone("[unknown show]"),
-                        _ => "[unknown]"
-                    };
+                        finishIndex++;
+                    }
 
-                    string subtitle = playoutItem.MediaItem switch
-                    {
-                        Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                            em => em.Title ?? string.Empty,
-                            () => string.Empty),
-                        _ => string.Empty
-                    };
+                    PlayoutItem finishItem = sorted[finishIndex];
+                    i = finishIndex;
 
-                    string description = playoutItem.MediaItem switch
-                    {
-                        Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
-                        Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
-                            .IfNone(string.Empty),
-                        _ => string.Empty
-                    };
+                    string start = startItem.StartOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
+                    string stop = finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
 
-                    string contentRating = playoutItem.MediaItem switch
-                    {
-                        // TODO: re-implement content rating
-                        // Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.ContentRating).IfNone(string.Empty),
-                        _ => string.Empty
-                    };
+                    string title = GetTitle(startItem);
+                    string subtitle = GetSubtitle(startItem);
+                    string description = GetDescription(startItem);
+                    string contentRating = string.Empty;
 
                     xml.WriteStartElement("programme");
                     xml.WriteAttributeString("start", start);
                     xml.WriteAttributeString("stop", stop);
                     xml.WriteAttributeString("channel", channel.Number);
 
-                    if (playoutItem.MediaItem is Movie movie)
+                    if (!hasCustomTitle && startItem.MediaItem is Movie movie)
                     {
                         xml.WriteStartElement("category");
                         xml.WriteAttributeString("lang", "en");
@@ -150,7 +137,7 @@ namespace ErsatzTV.Core.Iptv
                     xml.WriteStartElement("previously-shown");
                     xml.WriteEndElement(); // previously-shown
 
-                    if (playoutItem.MediaItem is Episode episode)
+                    if (!hasCustomTitle && startItem.MediaItem is Episode episode)
                     {
                         Option<ShowMetadata> maybeMetadata =
                             Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();
@@ -209,6 +196,8 @@ namespace ErsatzTV.Core.Iptv
                     }
 
                     xml.WriteEndElement(); // programme
+
+                    i++;
                 }
             }
 
@@ -218,5 +207,58 @@ namespace ErsatzTV.Core.Iptv
             xml.Flush();
             return Encoding.UTF8.GetString(ms.ToArray());
         }
+
+        private static string GetTitle(PlayoutItem playoutItem)
+        {
+            if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+            {
+                return playoutItem.CustomTitle;
+            }
+
+            return playoutItem.MediaItem switch
+            {
+                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
+                    .IfNone("[unknown movie]"),
+                Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
+                    .IfNone("[unknown show]"),
+                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => $"{mvm.Artist} - {mvm.Title}")
+                    .IfNone("[unknown music video]"),
+                _ => "[unknown]"
+            };
+        }
+
+        private static string GetSubtitle(PlayoutItem playoutItem)
+        {
+            if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+            {
+                return string.Empty;
+            }
+
+            return playoutItem.MediaItem switch
+            {
+                Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                    em => em.Title ?? string.Empty,
+                    () => string.Empty),
+                _ => string.Empty
+            };
+        }
+
+        private static string GetDescription(PlayoutItem playoutItem)
+        {
+            if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+            {
+                return string.Empty;
+            }
+
+            return playoutItem.MediaItem switch
+            {
+                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
+                Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
+                    .IfNone(string.Empty),
+                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => mvm.Plot ?? string.Empty)
+                    .IfNone(string.Empty),
+                _ => string.Empty
+            };
+        }
     }
 }

ErsatzTV.Core/LanguageExtensions.cs

@@ -1,9 +1,11 @@
-using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Core
 {
+    [SuppressMessage("ReSharper", "VSTHRD003")]
     public static class LanguageExtensions
     {
         public static Either<BaseError, TR> ToEither<TR>(this Validation<BaseError, TR> validation) =>

ErsatzTV.Core/Metadata/LocalFileSystem.cs

@@ -36,17 +36,26 @@ namespace ErsatzTV.Core.Metadata
         public bool FileExists(string path) => File.Exists(path);
         public Task<byte[]> ReadAllBytes(string path) => File.ReadAllBytesAsync(path);
 
-        public Unit CopyFile(string source, string destination)
+        public async Task<Either<BaseError, Unit>> CopyFile(string source, string destination)
         {
-            string directory = Path.GetDirectoryName(destination) ?? string.Empty;
-            if (!Directory.Exists(directory))
+            try
             {
-                Directory.CreateDirectory(directory);
+                string directory = Path.GetDirectoryName(destination) ?? string.Empty;
+                if (!Directory.Exists(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                }
+
+                await using FileStream sourceStream = File.OpenRead(source);
+                await using FileStream destinationStream = File.Create(destination);
+                await sourceStream.CopyToAsync(destinationStream);
+
+                return Unit.Default;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
             }
-
-            File.Copy(source, destination, true);
-
-            return Unit.Default;
         }
     }
 }

ErsatzTV.Core/Metadata/LocalFolderScanner.cs

@@ -72,6 +72,7 @@ namespace ErsatzTV.Core.Metadata
                 {
                     Movie m => m.MediaVersions.Head(),
                     Episode e => e.MediaVersions.Head(),
+                    MusicVideo mv => mv.MediaVersions.Head(),
                     _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                 };
 
@@ -120,30 +121,47 @@ namespace ErsatzTV.Core.Metadata
 
             if (shouldRefresh)
             {
-                _logger.LogDebug("Refreshing {Attribute} from {Path}", artworkKind, artworkFile);
-                string cacheName = _imageCache.CopyArtworkToCache(artworkFile, artworkKind);
+                try
+                {
+                    _logger.LogDebug("Refreshing {Attribute} from {Path}", artworkKind, artworkFile);
+                    Either<BaseError, string> maybeCacheName =
+                        await _imageCache.CopyArtworkToCache(artworkFile, artworkKind);
 
-                await maybeArtwork.Match(
-                    async artwork =>
-                    {
-                        artwork.Path = cacheName;
-                        artwork.DateUpdated = lastWriteTime;
-                        await _metadataRepository.UpdateArtworkPath(artwork);
-                    },
-                    async () =>
-                    {
-                        var artwork = new Artwork
+                    return await maybeCacheName.Match(
+                        async cacheName =>
                         {
-                            Path = cacheName,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = lastWriteTime,
-                            ArtworkKind = artworkKind
-                        };
-                        metadata.Artwork.Add(artwork);
-                        await _metadataRepository.AddArtwork(metadata, artwork);
-                    });
+                            await maybeArtwork.Match(
+                                async artwork =>
+                                {
+                                    artwork.Path = cacheName;
+                                    artwork.DateUpdated = lastWriteTime;
+                                    await _metadataRepository.UpdateArtworkPath(artwork);
+                                },
+                                async () =>
+                                {
+                                    var artwork = new Artwork
+                                    {
+                                        Path = cacheName,
+                                        DateAdded = DateTime.UtcNow,
+                                        DateUpdated = lastWriteTime,
+                                        ArtworkKind = artworkKind
+                                    };
+                                    metadata.Artwork.Add(artwork);
+                                    await _metadataRepository.AddArtwork(metadata, artwork);
+                                });
 
-                return true;
+                            return true;
+                        },
+                        error =>
+                        {
+                            _logger.LogDebug("Failed to cache artwork from {Path}: {Error}", artworkFile, error.Value);
+                            return Task.FromResult(false);
+                        });
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error refreshing artwork");
+                }
             }
 
             return false;

ErsatzTV.Core/Metadata/LocalMetadataProvider.cs

@@ -7,6 +7,7 @@ using System.Xml.Serialization;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata.Nfo;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 using static LanguageExt.Prelude;
@@ -18,18 +19,21 @@ namespace ErsatzTV.Core.Metadata
         private static readonly XmlSerializer MovieSerializer = new(typeof(MovieNfo));
         private static readonly XmlSerializer EpisodeSerializer = new(typeof(TvShowEpisodeNfo));
         private static readonly XmlSerializer TvShowSerializer = new(typeof(TvShowNfo));
+        private static readonly XmlSerializer MusicVideoSerializer = new(typeof(MusicVideoNfo));
         private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly ILogger<LocalMetadataProvider> _logger;
 
         private readonly IMetadataRepository _metadataRepository;
         private readonly IMovieRepository _movieRepository;
+        private readonly IMusicVideoRepository _musicVideoRepository;
         private readonly ITelevisionRepository _televisionRepository;
 
         public LocalMetadataProvider(
             IMetadataRepository metadataRepository,
             IMovieRepository movieRepository,
             ITelevisionRepository televisionRepository,
+            IMusicVideoRepository musicVideoRepository,
             IFallbackMetadataProvider fallbackMetadataProvider,
             ILocalFileSystem localFileSystem,
             ILogger<LocalMetadataProvider> logger)
@@ -37,6 +41,7 @@ namespace ErsatzTV.Core.Metadata
             _metadataRepository = metadataRepository;
             _movieRepository = movieRepository;
             _televisionRepository = televisionRepository;
+            _musicVideoRepository = musicVideoRepository;
             _fallbackMetadataProvider = fallbackMetadataProvider;
             _localFileSystem = localFileSystem;
             _logger = logger;
@@ -65,39 +70,87 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
-        public Task<bool> RefreshSidecarMetadata(MediaItem mediaItem, string path) =>
-            mediaItem switch
+        public async Task<Option<MusicVideoMetadata>> GetMetadataForMusicVideo(string filePath)
+        {
+            string nfoFileName = Path.ChangeExtension(filePath, "nfo");
+            Option<MusicVideoMetadata> maybeMetadata = None;
+            if (_localFileSystem.FileExists(nfoFileName))
             {
-                Episode e => LoadMetadata(e, path)
-                    .Bind(
-                        maybeMetadata => maybeMetadata.Match(
-                            metadata => ApplyMetadataUpdate(e, metadata),
-                            () => Task.FromResult(false))),
-                Movie m => LoadMetadata(m, path)
-                    .Bind(
-                        maybeMetadata => maybeMetadata.Match(
-                            metadata => ApplyMetadataUpdate(m, metadata),
-                            () => Task.FromResult(false))),
-                _ => Task.FromResult(false)
-            };
+                maybeMetadata = await LoadMusicVideoMetadata(nfoFileName);
+            }
 
-        public Task<bool> RefreshSidecarMetadata(Show televisionShow, string showFolder) =>
-            LoadMetadata(televisionShow, showFolder).Bind(
+            return maybeMetadata.Map(
+                metadata =>
+                {
+                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                    return metadata;
+                });
+        }
+
+        public Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName) =>
+            LoadMovieMetadata(movie, nfoFileName).Bind(
+                maybeMetadata => maybeMetadata.Match(
+                    metadata => ApplyMetadataUpdate(movie, metadata),
+                    () => Task.FromResult(false)));
+
+        public Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName) =>
+            LoadTelevisionShowMetadata(nfoFileName).Bind(
                 maybeMetadata => maybeMetadata.Match(
                     metadata => ApplyMetadataUpdate(televisionShow, metadata),
                     () => Task.FromResult(false)));
 
-        public Task<bool> RefreshFallbackMetadata(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Episode e => ApplyMetadataUpdate(e, _fallbackMetadataProvider.GetFallbackMetadata(e)),
-                Movie m => ApplyMetadataUpdate(m, _fallbackMetadataProvider.GetFallbackMetadata(m)),
-                _ => Task.FromResult(false)
-            };
+        public Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName) =>
+            LoadEpisodeMetadata(episode, nfoFileName).Bind(
+                maybeMetadata => maybeMetadata.Match(
+                    metadata => ApplyMetadataUpdate(episode, metadata),
+                    () => Task.FromResult(false)));
+
+        public Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName) =>
+            LoadMusicVideoMetadata(nfoFileName).Bind(
+                maybeMetadata => maybeMetadata.Match(
+                    metadata => ApplyMetadataUpdate(musicVideo, metadata),
+                    () => Task.FromResult(false)));
+
+        public Task<bool> RefreshFallbackMetadata(Movie movie) =>
+            ApplyMetadataUpdate(movie, _fallbackMetadataProvider.GetFallbackMetadata(movie));
+
+        public Task<bool> RefreshFallbackMetadata(Episode episode) =>
+            ApplyMetadataUpdate(episode, _fallbackMetadataProvider.GetFallbackMetadata(episode));
 
         public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
             ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
 
+        private async Task<Option<MusicVideoMetadata>> LoadMusicVideoMetadata(string nfoFileName)
+        {
+            try
+            {
+                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+                Option<MusicVideoNfo> maybeNfo = MusicVideoSerializer.Deserialize(fileStream) as MusicVideoNfo;
+                return maybeNfo.Match<Option<MusicVideoMetadata>>(
+                    nfo => new MusicVideoMetadata
+                    {
+                        MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                        Artist = nfo.Artist,
+                        Album = nfo.Album,
+                        Title = nfo.Title,
+                        Plot = nfo.Plot,
+                        Year = GetYear(nfo.Year, nfo.Premiered),
+                        ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
+                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
+                    },
+                    None);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogInformation(ex, "Failed to read music video nfo metadata from {Path}", nfoFileName);
+                return None;
+            }
+        }
+
         private async Task<bool> ApplyMetadataUpdate(Episode episode, Tuple<EpisodeMetadata, int> metadataEpisodeNumber)
         {
             (EpisodeMetadata metadata, int episodeNumber) = metadataEpisodeNumber;
@@ -113,7 +166,7 @@ namespace ErsatzTV.Core.Metadata
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    
+
                     if (existing.DateAdded == DateTime.MinValue)
                     {
                         existing.DateAdded = metadata.DateAdded;
@@ -148,18 +201,16 @@ namespace ErsatzTV.Core.Metadata
             Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
                 async existing =>
                 {
-                    var updated = false;
-                    
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    
+
                     if (existing.DateAdded == DateTime.MinValue)
                     {
                         existing.DateAdded = metadata.DateAdded;
                     }
-                    
+
                     existing.DateUpdated = metadata.DateUpdated;
                     existing.MetadataKind = metadata.MetadataKind;
                     existing.OriginalTitle = metadata.OriginalTitle;
@@ -169,67 +220,12 @@ namespace ErsatzTV.Core.Metadata
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
 
-                    foreach (Genre genre in existing.Genres.Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Remove(genre);
-                        if (await _metadataRepository.RemoveGenre(genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Add(genre);
-                        if (await _movieRepository.AddGenre(existing, genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Tag tag in existing.Tags.Filter(t => metadata.Tags.All(t2 => t2.Name != t.Name))
-                        .ToList())
-                    {
-                        existing.Tags.Remove(tag);
-                        if (await _metadataRepository.RemoveTag(tag))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Tag tag in metadata.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
-                        .ToList())
-                    {
-                        existing.Tags.Add(tag);
-                        if (await _movieRepository.AddTag(existing, tag))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Studio studio in existing.Studios
-                        .Filter(s => metadata.Studios.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Studios.Remove(studio);
-                        if (await _metadataRepository.RemoveStudio(studio))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Studio studio in metadata.Studios
-                        .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Studios.Add(studio);
-                        if (await _movieRepository.AddStudio(existing, studio))
-                        {
-                            updated = true;
-                        }
-                    }
+                    bool updated = await UpdateMetadataCollections(
+                        existing,
+                        metadata,
+                        _movieRepository.AddGenre,
+                        _movieRepository.AddTag,
+                        _movieRepository.AddStudio);
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
@@ -248,13 +244,11 @@ namespace ErsatzTV.Core.Metadata
             Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
                 async existing =>
                 {
-                    var updated = false;
-
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
                     existing.Title = metadata.Title;
-                    
+
                     if (existing.DateAdded == DateTime.MinValue)
                     {
                         existing.DateAdded = metadata.DateAdded;
@@ -269,67 +263,12 @@ namespace ErsatzTV.Core.Metadata
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
 
-                    foreach (Genre genre in existing.Genres.Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Remove(genre);
-                        if (await _metadataRepository.RemoveGenre(genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Add(genre);
-                        if (await _televisionRepository.AddGenre(existing, genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Tag tag in existing.Tags.Filter(t => metadata.Tags.All(t2 => t2.Name != t.Name))
-                        .ToList())
-                    {
-                        existing.Tags.Remove(tag);
-                        if (await _metadataRepository.RemoveTag(tag))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Tag tag in metadata.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
-                        .ToList())
-                    {
-                        existing.Tags.Add(tag);
-                        if (await _televisionRepository.AddTag(existing, tag))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Studio studio in existing.Studios
-                        .Filter(s => metadata.Studios.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Studios.Remove(studio);
-                        if (await _metadataRepository.RemoveStudio(studio))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Studio studio in metadata.Studios
-                        .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Studios.Add(studio);
-                        if (await _televisionRepository.AddStudio(existing, studio))
-                        {
-                            updated = true;
-                        }
-                    }
+                    bool updated = await UpdateMetadataCollections(
+                        existing,
+                        metadata,
+                        _televisionRepository.AddGenre,
+                        _televisionRepository.AddTag,
+                        _televisionRepository.AddStudio);
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
@@ -344,38 +283,48 @@ namespace ErsatzTV.Core.Metadata
                     return await _metadataRepository.Add(metadata);
                 });
 
-        private async Task<Option<MovieMetadata>> LoadMetadata(Movie mediaItem, string nfoFileName)
-        {
-            if (nfoFileName == null || !File.Exists(nfoFileName))
-            {
-                _logger.LogDebug("NFO file does not exist at {Path}", nfoFileName);
-                return None;
-            }
+        private Task<bool> ApplyMetadataUpdate(MusicVideo musicVideo, MusicVideoMetadata metadata) =>
+            Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
+                async existing =>
+                {
+                    existing.Artist = metadata.Artist;
+                    existing.Title = metadata.Title;
+                    existing.Year = metadata.Year;
+                    existing.Plot = metadata.Plot;
+                    existing.Album = metadata.Album;
 
-            return await LoadMovieMetadata(mediaItem, nfoFileName);
-        }
+                    if (existing.DateAdded == DateTime.MinValue)
+                    {
+                        existing.DateAdded = metadata.DateAdded;
+                    }
 
-        private async Task<Option<Tuple<EpisodeMetadata, int>>> LoadMetadata(Episode mediaItem, string nfoFileName)
-        {
-            if (nfoFileName == null || !File.Exists(nfoFileName))
-            {
-                _logger.LogDebug("NFO file does not exist at {Path}", nfoFileName);
-                return None;
-            }
+                    existing.DateUpdated = metadata.DateUpdated;
+                    existing.MetadataKind = metadata.MetadataKind;
+                    existing.OriginalTitle = metadata.OriginalTitle;
+                    existing.ReleaseDate = metadata.ReleaseDate;
+                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
 
-            return await LoadEpisodeMetadata(mediaItem, nfoFileName);
-        }
+                    bool updated = await UpdateMetadataCollections(
+                        existing,
+                        metadata,
+                        _musicVideoRepository.AddGenre,
+                        _musicVideoRepository.AddTag,
+                        _musicVideoRepository.AddStudio);
 
-        private async Task<Option<ShowMetadata>> LoadMetadata(Show televisionShow, string nfoFileName)
-        {
-            if (nfoFileName == null || !File.Exists(nfoFileName))
-            {
-                _logger.LogDebug("NFO file does not exist at {Path}", nfoFileName);
-                return None;
-            }
+                    return await _metadataRepository.Update(existing) || updated;
+                },
+                async () =>
+                {
+                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                        : metadata.SortTitle;
+                    metadata.MusicVideoId = musicVideo.Id;
+                    musicVideo.MusicVideoMetadata = new List<MusicVideoMetadata> { metadata };
 
-            return await LoadTelevisionShowMetadata(nfoFileName);
-        }
+                    return await _metadataRepository.Add(metadata);
+                });
 
         private async Task<Option<ShowMetadata>> LoadTelevisionShowMetadata(string nfoFileName)
         {
@@ -437,7 +386,7 @@ namespace ErsatzTV.Core.Metadata
             }
         }
 
-        private async Task<Option<MovieMetadata>> LoadMovieMetadata(Movie mediaItem, string nfoFileName)
+        private async Task<Option<MovieMetadata>> LoadMovieMetadata(Movie movie, string nfoFileName)
         {
             try
             {
@@ -464,7 +413,7 @@ namespace ErsatzTV.Core.Metadata
             catch (Exception ex)
             {
                 _logger.LogInformation(ex, "Failed to read Movie nfo metadata from {Path}", nfoFileName);
-                return _fallbackMetadataProvider.GetFallbackMetadata(mediaItem);
+                return _fallbackMetadataProvider.GetFallbackMetadata(movie);
             }
         }
 
@@ -500,94 +449,79 @@ namespace ErsatzTV.Core.Metadata
             return DateTime.TryParse(aired, out DateTime parsed) ? parsed : fallback;
         }
 
-        [XmlRoot("movie")]
-        public class MovieNfo
+        private async Task<bool> UpdateMetadataCollections<T>(
+            T existing,
+            T incoming,
+            Func<T, Genre, Task<bool>> addGenre,
+            Func<T, Tag, Task<bool>> addTag,
+            Func<T, Studio, Task<bool>> addStudio)
+            where T : Domain.Metadata
         {
-            [XmlElement("title")]
-            public string Title { get; set; }
+            var updated = false;
 
-            [XmlElement("outline")]
-            public string Outline { get; set; }
+            foreach (Genre genre in existing.Genres.Filter(g => incoming.Genres.All(g2 => g2.Name != g.Name))
+                .ToList())
+            {
+                existing.Genres.Remove(genre);
+                if (await _metadataRepository.RemoveGenre(genre))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("year")]
-            public int Year { get; set; }
+            foreach (Genre genre in incoming.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
+                .ToList())
+            {
+                existing.Genres.Add(genre);
+                if (await addGenre(existing, genre))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("mpaa")]
-            public string ContentRating { get; set; }
+            foreach (Tag tag in existing.Tags.Filter(t => incoming.Tags.All(t2 => t2.Name != t.Name))
+                .ToList())
+            {
+                existing.Tags.Remove(tag);
+                if (await _metadataRepository.RemoveTag(tag))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("premiered")]
-            public DateTime Premiered { get; set; }
+            foreach (Tag tag in incoming.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
+                .ToList())
+            {
+                existing.Tags.Add(tag);
+                if (await addTag(existing, tag))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("plot")]
-            public string Plot { get; set; }
+            foreach (Studio studio in existing.Studios
+                .Filter(s => incoming.Studios.All(s2 => s2.Name != s.Name))
+                .ToList())
+            {
+                existing.Studios.Remove(studio);
+                if (await _metadataRepository.RemoveStudio(studio))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("tagline")]
-            public string Tagline { get; set; }
+            foreach (Studio studio in incoming.Studios
+                .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                .ToList())
+            {
+                existing.Studios.Add(studio);
+                if (await addStudio(existing, studio))
+                {
+                    updated = true;
+                }
+            }
 
-            [XmlElement("genre")]
-            public List<string> Genres { get; set; }
-
-            [XmlElement("tag")]
-            public List<string> Tags { get; set; }
-
-            [XmlElement("studio")]
-            public List<string> Studios { get; set; }
-        }
-
-        [XmlRoot("tvshow")]
-        public class TvShowNfo
-        {
-            [XmlElement("title")]
-            public string Title { get; set; }
-
-            [XmlElement("year")]
-            public int Year { get; set; }
-
-            [XmlElement("plot")]
-            public string Plot { get; set; }
-
-            [XmlElement("outline")]
-            public string Outline { get; set; }
-
-            [XmlElement("tagline")]
-            public string Tagline { get; set; }
-
-            [XmlElement("premiered")]
-            public string Premiered { get; set; }
-
-            [XmlElement("genre")]
-            public List<string> Genres { get; set; }
-
-            [XmlElement("tag")]
-            public List<string> Tags { get; set; }
-
-            [XmlElement("studio")]
-            public List<string> Studios { get; set; }
-        }
-
-        [XmlRoot("episodedetails")]
-        public class TvShowEpisodeNfo
-        {
-            [XmlElement("showtitle")]
-            public string ShowTitle { get; set; }
-
-            [XmlElement("title")]
-            public string Title { get; set; }
-
-            [XmlElement("episode")]
-            public int Episode { get; set; }
-
-            [XmlElement("season")]
-            public int Season { get; set; }
-
-            [XmlElement("mpaa")]
-            public string ContentRating { get; set; }
-
-            [XmlElement("aired")]
-            public string Aired { get; set; }
-
-            [XmlElement("plot")]
-            public string Plot { get; set; }
+            return updated;
         }
     }
 }

ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs

@@ -37,6 +37,7 @@ namespace ErsatzTV.Core.Metadata
                 {
                     Movie m => m.MediaVersions.Head().MediaFiles.Head().Path,
                     Episode e => e.MediaVersions.Head().MediaFiles.Head().Path,
+                    MusicVideo mv => mv.MediaVersions.Head().MediaFiles.Head().Path,
                     _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                 };
 
@@ -63,6 +64,7 @@ namespace ErsatzTV.Core.Metadata
             {
                 Movie m => m.MediaVersions.Head(),
                 Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
                 _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
             };
 

ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Images;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Metadata
+{
+    public class MusicVideoFolderScanner : LocalFolderScanner, IMusicVideoFolderScanner
+    {
+        private readonly ILocalFileSystem _localFileSystem;
+        private readonly ILocalMetadataProvider _localMetadataProvider;
+        private readonly ILogger<MusicVideoFolderScanner> _logger;
+        private readonly IMusicVideoRepository _musicVideoRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public MusicVideoFolderScanner(
+            ILocalFileSystem localFileSystem,
+            ILocalStatisticsProvider localStatisticsProvider,
+            ILocalMetadataProvider localMetadataProvider,
+            IMetadataRepository metadataRepository,
+            IImageCache imageCache,
+            ISearchIndex searchIndex,
+            IMusicVideoRepository musicVideoRepository,
+            ILogger<MusicVideoFolderScanner> logger) : base(
+            localFileSystem,
+            localStatisticsProvider,
+            metadataRepository,
+            imageCache,
+            logger)
+        {
+            _localFileSystem = localFileSystem;
+            _localMetadataProvider = localMetadataProvider;
+            _searchIndex = searchIndex;
+            _musicVideoRepository = musicVideoRepository;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> ScanFolder(
+            LibraryPath libraryPath,
+            string ffprobePath,
+            DateTimeOffset lastScan)
+        {
+            if (!_localFileSystem.IsLibraryPathAccessible(libraryPath))
+            {
+                return new MediaSourceInaccessible();
+            }
+
+            var folderQueue = new Queue<string>();
+            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path).OrderBy(identity))
+            {
+                folderQueue.Enqueue(folder);
+            }
+
+            while (folderQueue.Count > 0)
+            {
+                string movieFolder = folderQueue.Dequeue();
+
+                var allFiles = _localFileSystem.ListFiles(movieFolder)
+                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                    .Filter(
+                        f => !ExtraFiles.Any(
+                            e => Path.GetFileNameWithoutExtension(f).EndsWith(e, StringComparison.OrdinalIgnoreCase)))
+                    .ToList();
+
+                if (allFiles.Count == 0)
+                {
+                    foreach (string subdirectory in _localFileSystem.ListSubdirectories(movieFolder).OrderBy(identity))
+                    {
+                        folderQueue.Enqueue(subdirectory);
+                    }
+
+                    continue;
+                }
+
+                if (_localFileSystem.GetLastWriteTime(movieFolder) < lastScan)
+                {
+                    continue;
+                }
+
+                foreach (string file in allFiles.OrderBy(identity))
+                {
+                    // TODO: figure out how to rebuild playouts
+                    Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo =
+                        await FindOrCreateMusicVideo(libraryPath, file)
+                            .BindT(musicVideo => UpdateStatistics(musicVideo, ffprobePath))
+                            .BindT(UpdateMetadata)
+                            .BindT(UpdateThumbnail);
+
+                    await maybeMusicVideo.Match(
+                        async result =>
+                        {
+                            if (result.IsAdded)
+                            {
+                                await _searchIndex.AddItems(new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
+                            {
+                                await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
+                            }
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning("Error processing music video at {Path}: {Error}", file, error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+            }
+
+            foreach (string path in await _musicVideoRepository.FindMusicVideoPaths(libraryPath))
+            {
+                if (!_localFileSystem.FileExists(path))
+                {
+                    _logger.LogInformation("Removing missing music video at {Path}", path);
+                    List<int> ids = await _musicVideoRepository.DeleteByPath(libraryPath, path);
+                    await _searchIndex.RemoveItems(ids);
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> FindOrCreateMusicVideo(
+            LibraryPath libraryPath,
+            string filePath)
+        {
+            Option<MusicVideoMetadata> maybeMetadata = await _localMetadataProvider.GetMetadataForMusicVideo(filePath);
+            return await maybeMetadata.Match(
+                async metadata =>
+                {
+                    Option<MusicVideo> maybeMusicVideo =
+                        await _musicVideoRepository.GetByMetadata(libraryPath, metadata);
+                    return await maybeMusicVideo.Match(
+                        musicVideo =>
+                            Right<BaseError, MediaItemScanResult<MusicVideo>>(
+                                    new MediaItemScanResult<MusicVideo>(musicVideo))
+                                .AsTask(),
+                        async () => await _musicVideoRepository.Add(libraryPath, filePath, metadata));
+                },
+                () => Left<BaseError, MediaItemScanResult<MusicVideo>>(
+                    BaseError.New("Unable to locate metadata for music video")).AsTask());
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMetadata(
+            MediaItemScanResult<MusicVideo> result)
+        {
+            try
+            {
+                MusicVideo musicVideo = result.Item;
+                return await LocateNfoFile(musicVideo).Match<Task<Either<BaseError, MediaItemScanResult<MusicVideo>>>>(
+                    async nfoFile =>
+                    {
+                        bool shouldUpdate = Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
+                            m => m.MetadataKind == MetadataKind.Fallback ||
+                                 m.DateUpdated < _localFileSystem.GetLastWriteTime(nfoFile),
+                            true);
+
+                        if (shouldUpdate)
+                        {
+                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                            if (await _localMetadataProvider.RefreshSidecarMetadata(musicVideo, nfoFile))
+                            {
+                                result.IsUpdated = true;
+                            }
+                        }
+
+                        return result;
+                    },
+                    () => Left<BaseError, MediaItemScanResult<MusicVideo>>(
+                        BaseError.New("Unable to locate metadata for music video")).AsTask());
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        private Option<string> LocateNfoFile(MusicVideo musicVideo)
+        {
+            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+            return Optional(Path.ChangeExtension(path, "nfo"))
+                .Filter(s => _localFileSystem.FileExists(s))
+                .HeadOrNone();
+        }
+
+        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateThumbnail(
+            MediaItemScanResult<MusicVideo> result)
+        {
+            try
+            {
+                MusicVideo musicVideo = result.Item;
+                await LocateThumbnail(musicVideo).IfSomeAsync(
+                    async thumbnailFile =>
+                    {
+                        MusicVideoMetadata metadata = musicVideo.MusicVideoMetadata.Head();
+                        await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail);
+                    });
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
+        }
+
+        private Option<string> LocateThumbnail(MusicVideo musicVideo)
+        {
+            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+            return ImageFileExtensions
+                .Map(ext => Path.ChangeExtension(path, ext))
+                .Filter(f => _localFileSystem.FileExists(f))
+                .HeadOrNone();
+        }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    [XmlRoot("movie")]
+    public class MovieNfo
+    {
+        [XmlElement("title")]
+        public string Title { get; set; }
+
+        [XmlElement("outline")]
+        public string Outline { get; set; }
+
+        [XmlElement("year")]
+        public int Year { get; set; }
+
+        [XmlElement("mpaa")]
+        public string ContentRating { get; set; }
+
+        [XmlElement("premiered")]
+        public DateTime Premiered { get; set; }
+
+        [XmlElement("plot")]
+        public string Plot { get; set; }
+
+        [XmlElement("tagline")]
+        public string Tagline { get; set; }
+
+        [XmlElement("genre")]
+        public List<string> Genres { get; set; }
+
+        [XmlElement("tag")]
+        public List<string> Tags { get; set; }
+
+        [XmlElement("studio")]
+        public List<string> Studios { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/MusicVideoNfo.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    [XmlRoot("musicvideo")]
+    public class MusicVideoNfo
+    {
+        [XmlElement("artist")]
+        public string Artist { get; set; }
+
+        [XmlElement("title")]
+        public string Title { get; set; }
+
+        [XmlElement("album")]
+        public string Album { get; set; }
+
+        [XmlElement("plot")]
+        public string Plot { get; set; }
+
+        [XmlElement("premiered")]
+        public string Premiered { get; set; }
+
+        [XmlElement("year")]
+        public int Year { get; set; }
+
+        [XmlElement("genre")]
+        public List<string> Genres { get; set; }
+
+        [XmlElement("tag")]
+        public List<string> Tags { get; set; }
+
+        [XmlElement("studio")]
+        public List<string> Studios { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs

@@ -0,0 +1,29 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    [XmlRoot("episodedetails")]
+    public class TvShowEpisodeNfo
+    {
+        [XmlElement("showtitle")]
+        public string ShowTitle { get; set; }
+
+        [XmlElement("title")]
+        public string Title { get; set; }
+
+        [XmlElement("episode")]
+        public int Episode { get; set; }
+
+        [XmlElement("season")]
+        public int Season { get; set; }
+
+        [XmlElement("mpaa")]
+        public string ContentRating { get; set; }
+
+        [XmlElement("aired")]
+        public string Aired { get; set; }
+
+        [XmlElement("plot")]
+        public string Plot { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Core.Metadata.Nfo
+{
+    [XmlRoot("tvshow")]
+    public class TvShowNfo
+    {
+        [XmlElement("title")]
+        public string Title { get; set; }
+
+        [XmlElement("year")]
+        public int Year { get; set; }
+
+        [XmlElement("plot")]
+        public string Plot { get; set; }
+
+        [XmlElement("outline")]
+        public string Outline { get; set; }
+
+        [XmlElement("tagline")]
+        public string Tagline { get; set; }
+
+        [XmlElement("premiered")]
+        public string Premiered { get; set; }
+
+        [XmlElement("genre")]
+        public List<string> Genres { get; set; }
+
+        [XmlElement("tag")]
+        public List<string> Tags { get; set; }
+
+        [XmlElement("studio")]
+        public List<string> Studios { get; set; }
+    }
+}

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -80,9 +80,22 @@ namespace ErsatzTV.Core.Metadata
                             await _searchIndex.UpdateItems(new List<MediaItem> { result.Item });
                         }
 
-                        await ScanSeasons(libraryPath, ffprobePath, result.Item, showFolder, lastScan);
+                        await ScanSeasons(
+                            libraryPath,
+                            ffprobePath,
+                            result.Item,
+                            showFolder,
+                            // force scanning all folders if we're adding a new show
+                            result.IsAdded ? DateTimeOffset.MinValue : lastScan);
                     },
-                    _ => Task.FromResult(Unit.Default));
+                    error =>
+                    {
+                        _logger.LogWarning(
+                            "Error processing show in folder {Folder}: {Error}",
+                            showFolder,
+                            error.Value);
+                        return Task.FromResult(Unit.Default);
+                    });
             }
 
             foreach (string path in await _televisionRepository.FindEpisodePaths(libraryPath))
@@ -132,7 +145,14 @@ namespace ErsatzTV.Core.Metadata
 
                         await maybeSeason.Match(
                             season => ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder, lastScan),
-                            _ => Task.FromResult(Unit.Default));
+                            error =>
+                            {
+                                _logger.LogWarning(
+                                    "Error processing season in folder {Folder}: {Error}",
+                                    seasonFolder,
+                                    error.Value);
+                                return Task.FromResult(Unit.Default);
+                            });
                     });
             }
 

ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs

@@ -48,6 +48,9 @@ namespace ErsatzTV.Core.Scheduling
                     Movie m => m.MovieMetadata.HeadOrNone().Match(
                         mm => mm.ReleaseDate ?? DateTime.MaxValue,
                         () => DateTime.MaxValue),
+                    MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                        mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                        () => DateTime.MaxValue),
                     _ => DateTime.MaxValue
                 };
 
@@ -59,6 +62,9 @@ namespace ErsatzTV.Core.Scheduling
                     Movie m => m.MovieMetadata.HeadOrNone().Match(
                         mm => mm.ReleaseDate ?? DateTime.MaxValue,
                         () => DateTime.MaxValue),
+                    MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                        mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                        () => DateTime.MaxValue),
                     _ => DateTime.MaxValue
                 };
 

ErsatzTV.Core/Scheduling/PlayoutBuilder.cs

@@ -57,7 +57,7 @@ namespace ErsatzTV.Core.Scheduling
                         case ProgramScheduleItemCollectionType.Collection:
                             Option<List<MediaItem>> maybeItems =
                                 await _mediaCollectionRepository.GetItems(collectionKey.CollectionId ?? 0);
-                            return Tuple(collectionKey, maybeItems.IfNone(new List<MediaItem>()));
+                            return Tuple(collectionKey, await maybeItems.IfNoneAsync(new List<MediaItem>()));
                         case ProgramScheduleItemCollectionType.TelevisionShow:
                             List<Episode> showItems =
                                 await _televisionRepository.GetShowItems(collectionKey.MediaItemId ?? 0);
@@ -99,6 +99,8 @@ namespace ErsatzTV.Core.Scheduling
                                    TimeSpan.Zero,
                         Episode e => e.MediaVersions.HeadOrNone().Map(mv => mv.Duration).IfNone(TimeSpan.Zero) ==
                                      TimeSpan.Zero,
+                        MusicVideo mv => mv.MediaVersions.HeadOrNone().Map(v => v.Duration).IfNone(TimeSpan.Zero) ==
+                                         TimeSpan.Zero,
                         _ => true
                     })).Map(c => c.Key);
             if (zeroDurationCollection.IsSome)
@@ -145,8 +147,12 @@ namespace ErsatzTV.Core.Scheduling
             // start with the previously-decided schedule item
             int index = sortedScheduleItems.IndexOf(startAnchor.NextScheduleItem);
 
-            Option<int> multipleRemaining = None;
-            Option<DateTimeOffset> durationFinish = None;
+            // start with the previous multiple/duration states
+            Option<int> multipleRemaining = Optional(startAnchor.MultipleRemaining);
+            Option<DateTimeOffset> durationFinish = startAnchor.DurationFinishOffset;
+
+            bool customGroup = multipleRemaining.IsSome || durationFinish.IsSome;
+
             // loop until we're done filling the desired amount of time
             while (currentTime < playoutFinish)
             {
@@ -161,7 +167,7 @@ namespace ErsatzTV.Core.Scheduling
                     durationFinish.IsSome);
 
                 IMediaCollectionEnumerator enumerator = collectionEnumerators[CollectionKeyForItem(scheduleItem)];
-                enumerator.Current.IfSome(
+                await enumerator.Current.IfSomeAsync(
                     mediaItem =>
                     {
                         _logger.LogDebug(
@@ -176,6 +182,7 @@ namespace ErsatzTV.Core.Scheduling
                         {
                             Movie m => m.MediaVersions.Head(),
                             Episode e => e.MediaVersions.Head(),
+                            MusicVideo mv => mv.MediaVersions.Head(),
                             _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
                         };
 
@@ -183,9 +190,15 @@ namespace ErsatzTV.Core.Scheduling
                         {
                             MediaItemId = mediaItem.Id,
                             Start = itemStartTime.UtcDateTime,
-                            Finish = itemStartTime.UtcDateTime + version.Duration
+                            Finish = itemStartTime.UtcDateTime + version.Duration,
+                            CustomGroup = customGroup
                         };
 
+                        if (!string.IsNullOrWhiteSpace(scheduleItem.CustomTitle))
+                        {
+                            playoutItem.CustomTitle = scheduleItem.CustomTitle;
+                        }
+
                         currentTime = itemStartTime + version.Duration;
                         enumerator.MoveNext();
 
@@ -199,11 +212,13 @@ namespace ErsatzTV.Core.Scheduling
                                     "Advancing to next schedule item after playout mode {PlayoutMode}",
                                     "One");
                                 index++;
+                                customGroup = false;
                                 break;
                             case ProgramScheduleItemMultiple multiple:
                                 if (multipleRemaining.IsNone)
                                 {
                                     multipleRemaining = multiple.Count;
+                                    customGroup = true;
                                 }
 
                                 multipleRemaining = multipleRemaining.Map(i => i - 1);
@@ -214,6 +229,7 @@ namespace ErsatzTV.Core.Scheduling
                                         "Multiple");
                                     index++;
                                     multipleRemaining = None;
+                                    customGroup = false;
                                 }
 
                                 break;
@@ -221,10 +237,13 @@ namespace ErsatzTV.Core.Scheduling
                                 enumerator.Current.Do(
                                     peekMediaItem =>
                                     {
+                                        customGroup = true;
+
                                         MediaVersion peekVersion = peekMediaItem switch
                                         {
                                             Movie m => m.MediaVersions.Head(),
                                             Episode e => e.MediaVersions.Head(),
+                                            MusicVideo mv => mv.MediaVersions.Head(),
                                             _ => throw new ArgumentOutOfRangeException(nameof(peekMediaItem))
                                         };
 
@@ -247,6 +266,7 @@ namespace ErsatzTV.Core.Scheduling
                                                 "Advancing to next schedule item after playout mode {PlayoutMode}",
                                                 "Flood");
                                             index++;
+                                            customGroup = false;
                                         }
                                     });
                                 break;
@@ -258,6 +278,7 @@ namespace ErsatzTV.Core.Scheduling
                                         {
                                             Movie m => m.MediaVersions.Head(),
                                             Episode e => e.MediaVersions.Head(),
+                                            MusicVideo mv => mv.MediaVersions.Head(),
                                             _ => throw new ArgumentOutOfRangeException(nameof(peekMediaItem))
                                         };
 
@@ -265,6 +286,7 @@ namespace ErsatzTV.Core.Scheduling
                                         if (durationFinish.IsNone)
                                         {
                                             durationFinish = itemStartTime + duration.PlayoutDuration;
+                                            customGroup = true;
                                         }
 
                                         bool willNotFinishInTime =
@@ -277,6 +299,7 @@ namespace ErsatzTV.Core.Scheduling
                                                 "Advancing to next schedule item after playout mode {PlayoutMode}",
                                                 "Duration");
                                             index++;
+                                            customGroup = false;
 
                                             if (duration.OfflineTail)
                                             {
@@ -298,7 +321,9 @@ namespace ErsatzTV.Core.Scheduling
             {
                 NextScheduleItem = nextScheduleItem,
                 NextScheduleItemId = nextScheduleItem.Id,
-                NextStart = GetStartTimeAfter(nextScheduleItem, currentTime).UtcDateTime
+                NextStart = GetStartTimeAfter(nextScheduleItem, currentTime).UtcDateTime,
+                MultipleRemaining = multipleRemaining.IsSome ? multipleRemaining.ValueUnsafe() : null,
+                DurationFinish = durationFinish.IsSome ? durationFinish.ValueUnsafe().UtcDateTime : null
             };
 
             // build program schedule anchors
@@ -459,6 +484,9 @@ namespace ErsatzTV.Core.Scheduling
                 Movie m => m.MovieMetadata.HeadOrNone().Match(
                     mm => mm.Title ?? string.Empty,
                     () => "[unknown movie]"),
+                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                    mvm => $"{mvm.Artist} - {mvm.Title}",
+                    () => "[unknown music video]"),
                 _ => string.Empty
             };
 

ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MusicVideoConfiguration.cs

@@ -0,0 +1,23 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations
+{
+    public class MusicVideoConfiguration : IEntityTypeConfiguration<MusicVideo>
+    {
+        public void Configure(EntityTypeBuilder<MusicVideo> builder)
+        {
+            builder.ToTable("MusicVideo");
+
+            builder.HasMany(m => m.MusicVideoMetadata)
+                .WithOne(m => m.MusicVideo)
+                .HasForeignKey(m => m.MusicVideoId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(m => m.MediaVersions)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/Configurations/Metadata/MusicVideoMetadataConfiguration.cs

@@ -0,0 +1,30 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations
+{
+    public class MusicVideoMetadataConfiguration : IEntityTypeConfiguration<MusicVideoMetadata>
+    {
+        public void Configure(EntityTypeBuilder<MusicVideoMetadata> builder)
+        {
+            builder.ToTable("MusicVideoMetadata");
+
+            builder.HasMany(mm => mm.Artwork)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(mm => mm.Genres)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(mm => mm.Tags)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.HasMany(mm => mm.Studios)
+                .WithOne()
+                .OnDelete(DeleteBehavior.Cascade);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/DbInitializer.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 
@@ -8,7 +10,7 @@ namespace ErsatzTV.Infrastructure.Data
 {
     public static class DbInitializer
     {
-        public static Unit Initialize(TvContext context)
+        public static async Task<Unit> Initialize(TvContext context, CancellationToken cancellationToken)
         {
             if (context.Resolutions.Any())
             {
@@ -22,28 +24,28 @@ namespace ErsatzTV.Infrastructure.Data
                 new() { Id = 3, Name = "1920x1080", Width = 1920, Height = 1080 },
                 new() { Id = 4, Name = "3840x2160", Width = 3840, Height = 2160 }
             };
-            context.Resolutions.AddRange(resolutions);
-            context.SaveChanges();
+            await context.Resolutions.AddRangeAsync(resolutions, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
 
             var resolutionConfig = new ConfigElement
             {
                 Key = ConfigElementKey.FFmpegDefaultResolutionId.Key,
                 Value = "3" // 1920x1080
             };
-            context.ConfigElements.Add(resolutionConfig);
-            context.SaveChanges();
+            await context.ConfigElements.AddAsync(resolutionConfig, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
 
             var defaultProfile = FFmpegProfile.New("1920x1080 x264 ac3", resolutions[2]);
-            context.FFmpegProfiles.Add(defaultProfile);
-            context.SaveChanges();
+            await context.FFmpegProfiles.AddAsync(defaultProfile, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
 
             var profileConfig = new ConfigElement
             {
                 Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
                 Value = defaultProfile.Id.ToString()
             };
-            context.ConfigElements.Add(profileConfig);
-            context.SaveChanges();
+            await context.ConfigElements.AddAsync(profileConfig, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
 
             var defaultChannel = new Channel(Guid.NewGuid())
             {
@@ -52,8 +54,8 @@ namespace ErsatzTV.Infrastructure.Data
                 FFmpegProfile = defaultProfile,
                 StreamingMode = StreamingMode.TransportStream
             };
-            context.Channels.Add(defaultChannel);
-            context.SaveChanges();
+            await context.Channels.AddAsync(defaultChannel, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
 
             // TODO: create looping static image that mentions configuring via web
             return Unit.Default;

ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs

@@ -62,12 +62,17 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(i => i.MediaItem)
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)
+                .Include(c => c.Playouts)
+                .ThenInclude(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mm => mm.Artwork)
                 .ToListAsync();
 
-        public async Task Update(Channel channel)
+        public Task Update(Channel channel)
         {
             _dbContext.Channels.Update(channel);
-            await _dbContext.SaveChangesAsync();
+            return _dbContext.SaveChangesAsync();
         }
 
         public async Task Delete(int channelId)

ErsatzTV.Infrastructure/Data/Repositories/ConfigElementRepository.cs

@@ -31,16 +31,16 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         public Task<Option<T>> GetValue<T>(ConfigElementKey key) =>
             Get(key).MapT(ce => (T) Convert.ChangeType(ce.Value, typeof(T)));
 
-        public async Task Update(ConfigElement configElement)
+        public Task Update(ConfigElement configElement)
         {
             _dbContext.ConfigElements.Update(configElement);
-            await _dbContext.SaveChangesAsync();
+            return _dbContext.SaveChangesAsync();
         }
 
-        public async Task Delete(ConfigElement configElement)
+        public Task Delete(ConfigElement configElement)
         {
             _dbContext.ConfigElements.Remove(configElement);
-            await _dbContext.SaveChangesAsync();
+            return _dbContext.SaveChangesAsync();
         }
     }
 }

ErsatzTV.Infrastructure/Data/Repositories/FFmpegProfileRepository.cs

@@ -32,10 +32,10 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(p => p.Resolution)
                 .ToListAsync();
 
-        public async Task Update(FFmpegProfile ffmpegProfile)
+        public Task Update(FFmpegProfile ffmpegProfile)
         {
             _dbContext.FFmpegProfiles.Update(ffmpegProfile);
-            await _dbContext.SaveChangesAsync();
+            return _dbContext.SaveChangesAsync();
         }
 
         public async Task Delete(int ffmpegProfileId)

ErsatzTV.Infrastructure/Data/Repositories/LibraryRepository.cs

@@ -52,7 +52,10 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
         public Task<List<Library>> GetAll()
         {
             using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.Libraries.ToListAsync();
+            return context.Libraries
+                .AsNoTracking()
+                .Include(l => l.MediaSource)
+                .ToListAsync();
         }
 
         public Task<Unit> UpdateLastScan(Library library) => _dbConnection.ExecuteAsync(

ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs

@@ -104,6 +104,8 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Show).ShowMetadata)
                 .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Season).Show)
@@ -128,6 +130,9 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)
                 .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mvm => mvm.Artwork)
+                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Show).ShowMetadata)
                 .ThenInclude(sm => sm.Artwork)
                 .Include(c => c.MediaItems)
@@ -196,6 +201,7 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
             result.AddRange(await GetShowItems(collection));
             result.AddRange(await GetSeasonItems(collection));
             result.AddRange(await GetEpisodeItems(collection));
+            result.AddRange(await GetMusicVideoItems(collection));
 
             return result.Distinct().ToList();
         }
@@ -215,6 +221,21 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ToListAsync();
         }
 
+        private async Task<List<MusicVideo>> GetMusicVideoItems(Collection collection)
+        {
+            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT m.Id FROM CollectionItem ci
+            INNER JOIN MusicVideo m ON m.Id = ci.MediaItemId
+            WHERE ci.CollectionId = @CollectionId",
+                new { CollectionId = collection.Id });
+
+            return await _dbContext.MusicVideos
+                .Include(m => m.MusicVideoMetadata)
+                .Include(m => m.MediaVersions)
+                .Filter(m => ids.Contains(m.Id))
+                .ToListAsync();
+        }
+
         private async Task<List<Episode>> GetShowItems(Collection collection)
         {
             IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(

ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs

@@ -156,6 +156,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                             VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path)",
                         parameters)
                     .ToUnit(),
+                MusicVideoMetadata => _dbConnection.ExecuteAsync(
+                        @"INSERT INTO Artwork (ArtworkKind, MusicVideoMetadataId, DateAdded, DateUpdated, Path)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path)",
+                        parameters)
+                    .ToUnit(),
                 _ => Task.FromResult(Unit.Default)
             };
         }

ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Infrastructure.Data.Repositories
+{
+    public class MusicVideoRepository : IMusicVideoRepository
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public MusicVideoRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<Option<MusicVideo>> GetByMetadata(LibraryPath libraryPath, MusicVideoMetadata metadata)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Option<int> maybeId = await dbContext.MusicVideoMetadata
+                .Where(s => s.Artist == metadata.Artist && s.Title == metadata.Title && s.Year == metadata.Year)
+                .Where(s => s.MusicVideo.LibraryPathId == libraryPath.Id)
+                .SingleOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.MusicVideoId);
+
+            return await maybeId.Match(
+                id =>
+                {
+                    return dbContext.MusicVideos
+                        .AsNoTracking()
+                        .Include(mv => mv.MusicVideoMetadata)
+                        .ThenInclude(mvm => mvm.Artwork)
+                        .Include(mv => mv.MusicVideoMetadata)
+                        .ThenInclude(mvm => mvm.Genres)
+                        .Include(mv => mv.MusicVideoMetadata)
+                        .ThenInclude(mvm => mvm.Tags)
+                        .Include(mv => mv.MusicVideoMetadata)
+                        .ThenInclude(mvm => mvm.Studios)
+                        .Include(mv => mv.LibraryPath)
+                        .ThenInclude(lp => lp.Library)
+                        .Include(mv => mv.MediaVersions)
+                        .ThenInclude(mv => mv.MediaFiles)
+                        .OrderBy(mv => mv.Id)
+                        .SingleOrDefaultAsync(mv => mv.Id == id)
+                        .Map(Optional);
+                },
+                () => Option<MusicVideo>.None.AsTask());
+        }
+
+        public async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> Add(
+            LibraryPath libraryPath,
+            string filePath,
+            MusicVideoMetadata metadata)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            try
+            {
+                metadata.DateAdded = DateTime.UtcNow;
+                metadata.Genres ??= new List<Genre>();
+                metadata.Tags ??= new List<Tag>();
+                metadata.Studios ??= new List<Studio>();
+                var musicVideo = new MusicVideo
+                {
+                    LibraryPathId = libraryPath.Id,
+                    MusicVideoMetadata = new List<MusicVideoMetadata> { metadata },
+                    MediaVersions = new List<MediaVersion>
+                    {
+                        new()
+                        {
+                            MediaFiles = new List<MediaFile>
+                            {
+                                new() { Path = filePath }
+                            },
+                            Streams = new List<MediaStream>()
+                        }
+                    }
+                };
+
+                await dbContext.MusicVideos.AddAsync(musicVideo);
+                await dbContext.SaveChangesAsync();
+                await dbContext.Entry(musicVideo).Reference(s => s.LibraryPath).LoadAsync();
+                await dbContext.Entry(musicVideo.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+
+                return new MediaItemScanResult<MusicVideo>(musicVideo) { IsAdded = true };
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.Message);
+            }
+        }
+
+        public Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath) =>
+            _dbConnection.QueryAsync<string>(
+                @"SELECT MF.Path
+                FROM MediaFile MF
+                INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
+                INNER JOIN MusicVideo M on MV.MusicVideoId = M.Id
+                INNER JOIN MediaItem MI on M.Id = MI.Id
+                WHERE MI.LibraryPathId = @LibraryPathId",
+                new { LibraryPathId = libraryPath.Id });
+
+        public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
+        {
+            List<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT M.Id
+                FROM MusicVideo M
+                INNER JOIN MediaItem MI on M.Id = MI.Id
+                INNER JOIN MediaVersion MV on M.Id = MV.EpisodeId
+                INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
+                WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
+                new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            foreach (int musicVideoId in ids)
+            {
+                MusicVideo musicVideo = await dbContext.MusicVideos.FindAsync(musicVideoId);
+                dbContext.MusicVideos.Remove(musicVideo);
+            }
+
+            await dbContext.SaveChangesAsync();
+
+            return ids;
+        }
+
+        public Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Genre (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+        public Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Tag (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+        public Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio) =>
+            _dbConnection.ExecuteAsync(
+                "INSERT INTO Studio (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+                new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+        public async Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.MusicVideoMetadata
+                .AsNoTracking()
+                .Filter(mvm => ids.Contains(mvm.MusicVideoId))
+                .Include(mvm => mvm.Artwork)
+                .OrderBy(mvm => mvm.SortTitle)
+                .ToListAsync();
+        }
+
+        public async Task<Option<MusicVideo>> GetMusicVideo(int musicVideoId)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.MusicVideos
+                .Include(m => m.MusicVideoMetadata)
+                .ThenInclude(m => m.Artwork)
+                .Include(m => m.MusicVideoMetadata)
+                .ThenInclude(m => m.Genres)
+                .Include(m => m.MusicVideoMetadata)
+                .ThenInclude(m => m.Tags)
+                .Include(m => m.MusicVideoMetadata)
+                .ThenInclude(m => m.Studios)
+                .OrderBy(m => m.Id)
+                .SingleOrDefaultAsync(m => m.Id == musicVideoId)
+                .Map(Optional);
+        }
+    }
+}

ErsatzTV.Infrastructure/Data/Repositories/PlayoutRepository.cs

@@ -65,7 +65,14 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Movie).MediaVersions)
                 .ThenInclude(mv => mv.Streams)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+                .ThenInclude(mv => mv.MediaFiles)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+                .ThenInclude(mv => mv.Streams)
                 .AsNoTracking()
+                .OrderBy(pi => pi.Start)
                 .SingleOrDefaultAsync()
                 .Map(Optional);
 
@@ -89,6 +96,11 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Movie).MediaVersions)
                 .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mm => mm.Artwork)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+                .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
                 .ThenInclude(em => em.Artwork)
                 .Include(i => i.MediaItem)
@@ -96,6 +108,9 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as Episode).Season)
                 .ThenInclude(s => s.SeasonMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Episode).Season.Show)
+                .ThenInclude(s => s.ShowMetadata)
                 .Filter(i => i.PlayoutId == playoutId)
                 .ToListAsync();
         }
@@ -110,10 +125,10 @@ namespace ErsatzTV.Infrastructure.Data.Repositories
                 .ToListAsync();
         }
 
-        public async Task Update(Playout playout)
+        public Task Update(Playout playout)
         {
             _dbContext.Playouts.Update(playout);
-            await _dbContext.SaveChangesAsync();
+            return _dbContext.SaveChangesAsync();
         }
 
         public async Task Delete(int playoutId)

ErsatzTV.Infrastructure/Data/TvContext.cs

@@ -27,6 +27,8 @@ namespace ErsatzTV.Infrastructure.Data
         public DbSet<MediaFile> MediaFiles { get; set; }
         public DbSet<Movie> Movies { get; set; }
         public DbSet<MovieMetadata> MovieMetadata { get; set; }
+        public DbSet<MusicVideo> MusicVideos { get; set; }
+        public DbSet<MusicVideoMetadata> MusicVideoMetadata { get; set; }
         public DbSet<Show> Shows { get; set; }
         public DbSet<ShowMetadata> ShowMetadata { get; set; }
         public DbSet<Season> Seasons { get; set; }

ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj

@@ -3,9 +3,14 @@
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
         <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+        <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="AsyncFixer" Version="1.5.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Dapper" Version="2.0.78" />
       <PackageReference Include="Lucene.Net" Version="4.8.0-beta00013" />
       <PackageReference Include="Lucene.Net.Analysis.Common" Version="4.8.0-beta00013" />
@@ -16,6 +21,10 @@
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
       <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.4" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
       <PackageReference Include="Refit" Version="6.0.38" />
       <PackageReference Include="SixLabors.ImageSharp" Version="1.0.3" />
     </ItemGroup>

ErsatzTV.Infrastructure/Images/ImageCache.cs

@@ -75,24 +75,32 @@ namespace ErsatzTV.Infrastructure.Images
             }
         }
 
-        public string CopyArtworkToCache(string path, ArtworkKind artworkKind)
+        public async Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind)
         {
-            var filenameKey = $"{path}:{_localFileSystem.GetLastWriteTime(path).ToFileTimeUtc()}";
-            byte[] hash = Crypto.ComputeHash(Encoding.UTF8.GetBytes(filenameKey));
-            string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
-            string subfolder = hex.Substring(0, 2);
-            string baseFolder = artworkKind switch
+            try
             {
-                ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
-                ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
-                ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
-                ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
-                _ => FileSystemLayout.LegacyImageCacheFolder
-            };
-            string target = Path.Combine(baseFolder, hex);
-            _localFileSystem.CopyFile(path, target);
-
-            return hex;
+                var filenameKey = $"{path}:{_localFileSystem.GetLastWriteTime(path).ToFileTimeUtc()}";
+                byte[] hash = Crypto.ComputeHash(Encoding.UTF8.GetBytes(filenameKey));
+                string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
+                string subfolder = hex.Substring(0, 2);
+                string baseFolder = artworkKind switch
+                {
+                    ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
+                    ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
+                    ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
+                    ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
+                    _ => FileSystemLayout.LegacyImageCacheFolder
+                };
+                string target = Path.Combine(baseFolder, hex);
+                Either<BaseError, Unit> maybeResult = await _localFileSystem.CopyFile(path, target);
+                return maybeResult.Match<Either<BaseError, string>>(
+                    _ => hex,
+                    error => error);
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.ToString());
+            }
         }
     }
 }

ErsatzTV.Infrastructure/Migrations/20210329193151_Add_PlayoutAnchor_DurationMultiple.cs

@@ -0,0 +1,34 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ErsatzTV.Infrastructure.Migrations
+{
+    public partial class Add_PlayoutAnchor_DurationMultiple : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                "Anchor_DurationFinish",
+                "Playout",
+                "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                "Anchor_MultipleRemaining",
+                "Playout",
+                "INTEGER",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                "Anchor_DurationFinish",
+                "Playout");
+
+            migrationBuilder.DropColumn(
+                "Anchor_MultipleRemaining",
+                "Playout");
+        }
+    }
+}

ErsatzTV.Infrastructure/Migrations/20210329204815_Add_ProgramScheduleItem_CustomTitle.cs

@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ErsatzTV.Infrastructure.Migrations
+{
+    public partial class Add_ProgramScheduleItem_CustomTitle : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                "CustomTitle",
+                "ProgramScheduleItem",
+                "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                "CustomGroup",
+                "PlayoutItem",
+                "INTEGER",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<string>(
+                "CustomTitle",
+                "PlayoutItem",
+                "TEXT",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                "CustomTitle",
+                "ProgramScheduleItem");
+
+            migrationBuilder.DropColumn(
+                "CustomGroup",
+                "PlayoutItem");
+
+            migrationBuilder.DropColumn(
+                "CustomTitle",
+                "PlayoutItem");
+        }
+    }
+}