add more template data to text graphics element (#2304)

CHANGELOG.md

@@ -25,7 +25,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     - Supported in playback troubleshooting and YAML playouts
     - Displays multi-line text in a specified font, color, location, z-index
     - Supports constant opacity and opacity expression
-    - Supports variable replacement for music videos
+    - Supports EPG and Media Item variable replacement
+      - EPG data is sourced from XMLTV
+      - Media Item data is sourced from the currently playing media item
   - Add `image` graphics element type
       - Supported in playback troubleshooting and YAML playouts
       - Displays an image, similar to a watermark

ErsatzTV.Core/FFmpeg/FFmpegLibraryProcessService.cs

@@ -515,6 +515,7 @@ public class FFmpegLibraryProcessService : IFFmpegProcessService
             graphicsEngineInput = new GraphicsEngineInput();
 
             graphicsEngineContext = new GraphicsEngineContext(
+                channel.Number,
                 audioVersion.MediaItem,
                 graphicsElementContexts,
                 new Resolution { Width = desiredState.ScaledSize.Width, Height = desiredState.ScaledSize.Height },

ErsatzTV.Core/Interfaces/Repositories/ITemplateDataRepository.cs

@@ -4,8 +4,7 @@ namespace ErsatzTV.Core.Interfaces.Repositories;
 
 public interface ITemplateDataRepository
 {
-    public Task<Option<Dictionary<string, object>>> GetMusicVideoTemplateData(
+    public Task<Option<Dictionary<string, object>>> GetMediaItemTemplateData(MediaItem mediaItem);
-        Resolution resolution,
+
-        TimeSpan streamSeek,
+    public Task<Option<Dictionary<string, object>>> GetEpgTemplateData(string channelNumber, DateTimeOffset time);
-        int musicVideoId);
 }

ErsatzTV.Core/Interfaces/Streaming/GraphicsEngineContext.cs

@@ -5,6 +5,7 @@ using ErsatzTV.Core.Graphics;
 namespace ErsatzTV.Core.Interfaces.Streaming;
 
 public record GraphicsEngineContext(
+    string ChannelNumber,
     MediaItem MediaItem,
     List<GraphicsElementContext> Elements,
     Resolution SquarePixelFrameSize,

ErsatzTV.Core/Metadata/EpgTemplateDataKey.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Metadata;
+
+public static class EpgTemplateDataKey
+{
+    public static readonly string Title = "Epg_Title";
+    public static readonly string SubTitle = "Epg_SubTitle";
+    public static readonly string Description = "Epg_Description";
+    public static readonly string Rating = "Epg_Rating";
+    public static readonly string Categories = "Epg_Categories";
+    public static readonly string Date = "Epg_Date";
+}

ErsatzTV.Core/Metadata/MediaItemTemplateDataKey.cs

@@ -0,0 +1,29 @@
+namespace ErsatzTV.Core.Metadata;
+
+public static class MediaItemTemplateDataKey
+{
+    public static readonly string Resolution = "Resolution";
+
+    public static readonly string Duration = "MediaItem_Duration";
+    public static readonly string StreamSeek = "MediaItem_StreamSeek";
+
+    // common
+    public static readonly string Title = "MediaItem_Title";
+    public static readonly string Plot = "MediaItem_Plot";
+    public static readonly string ReleaseDate = "MediaItem_ReleaseDate";
+    public static readonly string Studios = "MediaItem_Studios";
+    public static readonly string Directors = "MediaItem_Directors";
+    public static readonly string Genres = "MediaItem_Genres";
+
+    // episode/show
+    public static readonly string ShowTitle = "MediaItem_ShowTitle";
+    public static readonly string ShowYear = "MediaItem_ShowYear";
+    public static readonly string ShowContentRating = "MediaItem_ShowContentRating";
+    public static readonly string ShowGenres = "MediaItem_ShowGenres";
+
+    // music video
+    public static readonly string Track = "MediaItem_Track";
+    public static readonly string Album = "MediaItem_Album";
+    public static readonly string Artist = "MediaItem_Artist";
+    public static readonly string Artists = "MediaItem_Artists";
+}

ErsatzTV.Infrastructure/Data/Repositories/TemplateDataRepository.cs

@@ -1,17 +1,146 @@
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
+using ErsatzTV.Infrastructure.Epg;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Infrastructure.Data.Repositories;
 
-public class TemplateDataRepository(IDbContextFactory<TvContext> dbContextFactory) : ITemplateDataRepository
+public class TemplateDataRepository(ILocalFileSystem localFileSystem, IDbContextFactory<TvContext> dbContextFactory)
+    : ITemplateDataRepository
 {
-    public async Task<Option<Dictionary<string, object>>> GetMusicVideoTemplateData(
+    public async Task<Option<Dictionary<string, object>>> GetMediaItemTemplateData(MediaItem mediaItem) =>
-        Resolution resolution,
+        mediaItem switch
-        TimeSpan streamSeek,
+        {
-        int musicVideoId)
+            Movie => await GetMovieTemplateData(mediaItem.Id),
+            Episode => await GetEpisodeTemplateData(mediaItem.Id),
+            MusicVideo => await GetMusicVideoTemplateData(mediaItem.Id),
+            _ => Option<Dictionary<string, object>>.None
+        };
+
+    public async Task<Option<Dictionary<string, object>>> GetEpgTemplateData(string channelNumber, DateTimeOffset time)
+    {
+        try
+        {
+            string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channelNumber}.xml");
+            if (localFileSystem.FileExists(targetFile))
+            {
+                await using var stream = File.OpenRead(targetFile);
+                var maybeEpgProgramme = EpgReader.FindProgrammeAt(stream, time);
+                foreach (var epgProgramme in maybeEpgProgramme)
+                {
+                    return new Dictionary<string, object>
+                    {
+                        [EpgTemplateDataKey.Title] = epgProgramme.Title?.Value,
+                        [EpgTemplateDataKey.SubTitle] = epgProgramme.SubTitle?.Value,
+                        [EpgTemplateDataKey.Description] = epgProgramme.Description?.Value,
+                        [EpgTemplateDataKey.Rating] = epgProgramme.Rating?.Value,
+                        [EpgTemplateDataKey.Categories] = (epgProgramme.Categories ?? []).Map(c => c.Value).ToArray(),
+                        [EpgTemplateDataKey.Date] = epgProgramme.Date?.Value
+                    };
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+            throw;
+        }
+
+        return Option<Dictionary<string, object>>.None;
+    }
+
+    private async Task<Option<Dictionary<string, object>>> GetMovieTemplateData(int movieId)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
+
+        Option<Movie> maybeMovie = await dbContext.Movies
+            .AsNoTracking()
+            .Include(m => m.MediaVersions)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .SelectOneAsync(m => m.Id, m => m.Id == movieId);
+
+        foreach (var movie in maybeMovie)
+        {
+            foreach (var metadata in movie.MovieMetadata.HeadOrNone())
+            {
+                return new Dictionary<string, object>
+                {
+                    [MediaItemTemplateDataKey.Title] = metadata.Title,
+                    [MediaItemTemplateDataKey.Plot] = metadata.Plot,
+                    [MediaItemTemplateDataKey.ReleaseDate] = metadata.ReleaseDate,
+                    [MediaItemTemplateDataKey.Studios] = (metadata.Studios ?? []).Map(s => s.Name).OrderBy(identity),
+                    [MediaItemTemplateDataKey.Directors] = (metadata.Directors ?? []).Map(d => d.Name).OrderBy(identity),
+                    [MediaItemTemplateDataKey.Genres] = (metadata.Genres ?? []).Map(g => g.Name).OrderBy(identity),
+                    [MediaItemTemplateDataKey.Duration] = movie.GetHeadVersion().Duration
+                };
+            }
+        }
+
+        return Option<Dictionary<string, object>>.None;
+    }
+
+    private async Task<Option<Dictionary<string, object>>> GetEpisodeTemplateData(int episodeId)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
+
+        Option<Episode> maybeEpisode = await dbContext.Episodes
+            .AsNoTracking()
+            .Include(e => e.MediaVersions)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(e => e.EpisodeMetadata)
+            .ThenInclude(em => em.Studios)
+            .Include(e => e.EpisodeMetadata)
+            .ThenInclude(em => em.Directors)
+            .Include(e => e.EpisodeMetadata)
+            .ThenInclude(em => em.Genres)
+            .SelectOneAsync(e => e.Id, e => e.Id == episodeId);
+
+        var result = new Dictionary<string, object>();
+
+        foreach (var episode in maybeEpisode)
+        {
+            foreach (var showMetadata in Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten())
+            {
+                result.Add(MediaItemTemplateDataKey.ShowTitle, showMetadata.Title);
+                result.Add(MediaItemTemplateDataKey.ShowYear, showMetadata.Year);
+                result.Add(MediaItemTemplateDataKey.ShowContentRating, showMetadata.ContentRating);
+                result.Add(MediaItemTemplateDataKey.ShowGenres,
+                    (showMetadata.Genres ?? []).Map(s => s.Name).OrderBy(identity));
+            }
+
+            foreach (var metadata in episode.EpisodeMetadata.HeadOrNone())
+            {
+                result.Add(MediaItemTemplateDataKey.Title, metadata.Title);
+                result.Add(MediaItemTemplateDataKey.Plot, metadata.Plot);
+                result.Add(MediaItemTemplateDataKey.ReleaseDate, metadata.ReleaseDate);
+                result.Add(MediaItemTemplateDataKey.Studios,
+                    (metadata.Studios ?? []).Map(s => s.Name).OrderBy(identity));
+                result.Add(MediaItemTemplateDataKey.Directors,
+                    (metadata.Directors ?? []).Map(s => s.Name).OrderBy(identity));
+                result.Add(MediaItemTemplateDataKey.Genres,
+                    (metadata.Genres ?? []).Map(s => s.Name).OrderBy(identity));
+                result.Add(MediaItemTemplateDataKey.Duration, episode.GetHeadVersion().Duration);
+            }
+
+            return result;
+        }
+
+        return Option<Dictionary<string, object>>.None;
+    }
+
+    private async Task<Option<Dictionary<string, object>>> GetMusicVideoTemplateData(int musicVideoId)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
 
@@ -26,6 +155,8 @@ public class TemplateDataRepository(IDbContextFactory<TvContext> dbContextFactor
             .ThenInclude(mvm => mvm.Studios)
             .Include(mv => mv.MusicVideoMetadata)
             .ThenInclude(mvm => mvm.Directors)
+            .Include(mv => mv.MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
             .SelectOneAsync(mv => mv.Id, mv => mv.Id == musicVideoId);
 
         foreach (var musicVideo in maybeMusicVideo)
@@ -40,18 +171,17 @@ public class TemplateDataRepository(IDbContextFactory<TvContext> dbContextFactor
 
                 return new Dictionary<string, object>
                 {
-                    ["Resolution"] = resolution,
+                    [MediaItemTemplateDataKey.Title] = metadata.Title,
-                    ["Title"] = metadata.Title,
+                    [MediaItemTemplateDataKey.Track] = metadata.Track,
-                    ["Track"] = metadata.Track,
+                    [MediaItemTemplateDataKey.Album] = metadata.Album,
-                    ["Album"] = metadata.Album,
+                    [MediaItemTemplateDataKey.Plot] = metadata.Plot,
-                    ["Plot"] = metadata.Plot,
+                    [MediaItemTemplateDataKey.ReleaseDate] = metadata.ReleaseDate,
-                    ["ReleaseDate"] = metadata.ReleaseDate,
+                    [MediaItemTemplateDataKey.Artists] = (metadata.Artists ?? []).Map(a => a.Name).OrderBy(identity),
-                    ["Artists"] = (metadata.Artists ?? []).Map(a => a.Name).ToList(),
+                    [MediaItemTemplateDataKey.Artist] = artist,
-                    ["Artist"] = artist,
+                    [MediaItemTemplateDataKey.Studios] = (metadata.Studios ?? []).Map(s => s.Name).OrderBy(identity),
-                    ["Studios"] = (metadata.Studios ?? []).Map(s => s.Name).ToList(),
+                    [MediaItemTemplateDataKey.Directors] = (metadata.Directors ?? []).Map(d => d.Name).OrderBy(identity),
-                    ["Directors"] = (metadata.Directors ?? []).Map(s => s.Name).ToList(),
+                    [MediaItemTemplateDataKey.Genres] = (metadata.Genres ?? []).Map(g => g.Name).OrderBy(identity),
-                    ["Duration"] = musicVideo.GetHeadVersion().Duration,
+                    [MediaItemTemplateDataKey.Duration] = musicVideo.GetHeadVersion().Duration
-                    ["StreamSeek"] = streamSeek
                 };
             }
         }

ErsatzTV.Infrastructure/Epg/EpgReader.cs

@@ -0,0 +1,51 @@
+using System.Globalization;
+using System.Xml;
+using System.Xml.Serialization;
+using ErsatzTV.Infrastructure.Epg.Models;
+
+namespace ErsatzTV.Infrastructure.Epg;
+
+public static class EpgReader
+{
+    private const string XmlTvDateFormat = "yyyyMMddHHmmss zzz";
+
+    public static Option<EpgProgramme> FindProgrammeAt(Stream xmlStream, DateTimeOffset targetTime)
+    {
+        var serializer = new XmlSerializer(typeof(EpgProgramme));
+
+        var settings = new XmlReaderSettings
+        {
+            ConformanceLevel = ConformanceLevel.Fragment
+        };
+
+        using var reader = XmlReader.Create(xmlStream, settings);
+
+        while (reader.Read())
+        {
+            if (reader.NodeType != XmlNodeType.Element || reader.Name != "programme")
+            {
+                continue;
+            }
+
+            string startStr = reader.GetAttribute("start");
+            string stopStr = reader.GetAttribute("stop");
+
+            if (startStr == null || stopStr == null)
+            {
+                continue;
+            }
+
+            if (DateTimeOffset.TryParseExact(startStr, XmlTvDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var start) &&
+                DateTimeOffset.TryParseExact(stopStr, XmlTvDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var stop))
+            {
+                if (start <= targetTime && targetTime < stop)
+                {
+                    using var subtreeReader = reader.ReadSubtree();
+                    return Optional(serializer.Deserialize(subtreeReader) as EpgProgramme);
+                }
+            }
+        }
+
+        return Option<EpgProgramme>.None;
+    }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgCategory.cs

@@ -0,0 +1,12 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgCategory
+{
+    [XmlAttribute("lang")]
+    public string Lang { get; set; }
+
+    [XmlText]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgDate.cs

@@ -0,0 +1,9 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgDate
+{
+    [XmlText]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgDescription.cs

@@ -0,0 +1,12 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgDescription
+{
+    [XmlAttribute("lang")]
+    public string Lang { get; set; }
+
+    [XmlText]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgEpisodeNum.cs

@@ -0,0 +1,12 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgEpisodeNum
+{
+    [XmlAttribute("system")]
+    public string System { get; set; }
+
+    [XmlText]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgIcon.cs

@@ -0,0 +1,9 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgIcon
+{
+    [XmlAttribute("src")]
+    public string Src { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgProgramme.cs

@@ -0,0 +1,43 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+[XmlRoot("programme")]
+public class EpgProgramme
+{
+    [XmlAttribute("start")]
+    public string Start { get; set; }
+
+    [XmlAttribute("stop")]
+    public string Stop { get; set; }
+
+    [XmlAttribute("channel")]
+    public string Channel { get; set; }
+
+    [XmlElement("title")]
+    public EpgTitle Title { get; set; }
+
+    [XmlElement("sub-title")]
+    public EpgTitle SubTitle { get; set; }
+
+    [XmlElement("desc")]
+    public EpgDescription Description { get; set; }
+
+    [XmlElement("category")]
+    public List<EpgCategory> Categories { get; set; }
+
+    [XmlElement("icon")]
+    public EpgIcon Icon { get; set; }
+
+    [XmlElement("episode-num")]
+    public List<EpgEpisodeNum> EpisodeNums { get; set; }
+
+    [XmlElement("rating")]
+    public EpgRating Rating { get; set; }
+
+    [XmlElement("previously-shown")]
+    public object PreviouslyShown { get; set; } // Use object for presence check
+
+    [XmlElement("date")]
+    public EpgDate Date { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgRating.cs

@@ -0,0 +1,9 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgRating
+{
+    [XmlElement("value")]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Epg/Models/EpgTitle.cs

@@ -0,0 +1,12 @@
+using System.Xml.Serialization;
+
+namespace ErsatzTV.Infrastructure.Epg.Models;
+
+public class EpgTitle
+{
+    [XmlAttribute("lang")]
+    public string Lang { get; set; }
+
+    [XmlText]
+    public string Value { get; set; }
+}

ErsatzTV.Infrastructure/Streaming/GraphicsEngine.cs

@@ -1,8 +1,8 @@
 using System.IO.Pipelines;
 using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Streaming;
+using ErsatzTV.Core.Metadata;
 using Microsoft.Extensions.Logging;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
@@ -16,6 +16,39 @@ public class GraphicsEngine(ITemplateDataRepository templateDataRepository, ILog
     {
         GraphicsEngineFonts.LoadFonts(FileSystemLayout.FontsCacheFolder);
 
+        var templateVariables = new Dictionary<string, object>();
+
+        // init text element variables once
+        if (context.Elements.OfType<TextElementContext>().Any())
+        {
+            // common variables
+            templateVariables[MediaItemTemplateDataKey.Resolution] = context.FrameSize;
+            templateVariables[MediaItemTemplateDataKey.StreamSeek] = context.Seek;
+
+            // media item variables
+            var maybeTemplateData =
+                await templateDataRepository.GetMediaItemTemplateData(context.MediaItem);
+            foreach (var templateData in maybeTemplateData)
+            {
+                foreach (var variable in templateData)
+                {
+                    templateVariables.Add(variable.Key, variable.Value);
+                }
+            }
+
+            // epg variables
+            var startTime = context.ContentStartTime + context.Seek;
+            var maybeEpgData =
+                await templateDataRepository.GetEpgTemplateData(context.ChannelNumber, startTime);
+            foreach (var templateData in maybeEpgData)
+            {
+                foreach (var variable in templateData)
+                {
+                    templateVariables.Add(variable.Key, variable.Value);
+                }
+            }
+        }
+
         var elements = new List<IGraphicsElement>();
         foreach (var element in context.Elements)
         {
@@ -33,28 +66,12 @@ public class GraphicsEngine(ITemplateDataRepository templateDataRepository, ILog
                     elements.Add(new ImageElement(imageElementContext.ImageElement, logger));
                     break;
                 case TextElementContext textElementContext:
-                    var variables = new Dictionary<string, object>();
+                    var variables = templateVariables.ToDictionary();
                     foreach (var variable in textElementContext.Variables)
                     {
                         variables.Add(variable.Key, variable.Value);
                     }
 
-                    if (context.MediaItem is MusicVideo musicVideo)
-                    {
-                        var maybeTemplateData = await templateDataRepository.GetMusicVideoTemplateData(
-                            context.FrameSize,
-                            context.Seek,
-                            musicVideo.Id);
-
-                        foreach (var templateData in maybeTemplateData)
-                        {
-                            foreach (var variable in templateData)
-                            {
-                                variables.Add(variable.Key, variable.Value);
-                            }
-                        }
-
-                    }
                     elements.Add(new TextElement(textElementContext.TextElement, variables, logger));
                     break;
             }