< Summary - Jellyfin

Information
Class: Jellyfin.Drawing.Skia.StripCollageBuilder
Assembly: Jellyfin.Drawing.Skia
File(s): /srv/git/jellyfin/src/Jellyfin.Drawing.Skia/StripCollageBuilder.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 123
Coverable lines: 123
Total lines: 316
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 48
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
GetEncodedFormat(...)0%110100%
BuildSquareCollage(...)100%210%
BuildThumbCollage(...)100%210%
BuildThumbCollageBitmap(...)0%110100%
BuildSquareCollageBitmap(...)0%4260%
MeasureAndDrawText(...)0%620%
DrawText(...)0%420200%

File(s)

/srv/git/jellyfin/src/Jellyfin.Drawing.Skia/StripCollageBuilder.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.IO;
 5using System.Text.RegularExpressions;
 6using SkiaSharp;
 7using SkiaSharp.HarfBuzz;
 8
 9namespace Jellyfin.Drawing.Skia;
 10
 11/// <summary>
 12/// Used to build collages of multiple images arranged in vertical strips.
 13/// </summary>
 14public partial class StripCollageBuilder
 15{
 16    private readonly SkiaEncoder _skiaEncoder;
 17
 18    /// <summary>
 19    /// Initializes a new instance of the <see cref="StripCollageBuilder"/> class.
 20    /// </summary>
 21    /// <param name="skiaEncoder">The encoder to use for building collages.</param>
 22    public StripCollageBuilder(SkiaEncoder skiaEncoder)
 23    {
 024        _skiaEncoder = skiaEncoder;
 025    }
 26
 27    [GeneratedRegex(@"\p{IsArabic}|\p{IsArmenian}|\p{IsHebrew}|\p{IsSyriac}|\p{IsThaana}")]
 28    private static partial Regex IsRtlTextRegex();
 29
 30    /// <summary>
 31    /// Check which format an image has been encoded with using its filename extension.
 32    /// </summary>
 33    /// <param name="outputPath">The path to the image to get the format for.</param>
 34    /// <returns>The image format.</returns>
 35    public static SKEncodedImageFormat GetEncodedFormat(string outputPath)
 36    {
 037        ArgumentNullException.ThrowIfNull(outputPath);
 38
 039        var ext = Path.GetExtension(outputPath.AsSpan());
 40
 041        if (ext.Equals(".jpg", StringComparison.OrdinalIgnoreCase)
 042            || ext.Equals(".jpeg", StringComparison.OrdinalIgnoreCase))
 43        {
 044            return SKEncodedImageFormat.Jpeg;
 45        }
 46
 047        if (ext.Equals(".webp", StringComparison.OrdinalIgnoreCase))
 48        {
 049            return SKEncodedImageFormat.Webp;
 50        }
 51
 052        if (ext.Equals(".gif", StringComparison.OrdinalIgnoreCase))
 53        {
 054            return SKEncodedImageFormat.Gif;
 55        }
 56
 057        if (ext.Equals(".bmp", StringComparison.OrdinalIgnoreCase))
 58        {
 059            return SKEncodedImageFormat.Bmp;
 60        }
 61
 62        // default to png
 063        return SKEncodedImageFormat.Png;
 64    }
 65
 66    /// <summary>
 67    /// Create a square collage.
 68    /// </summary>
 69    /// <param name="paths">The paths of the images to use in the collage.</param>
 70    /// <param name="outputPath">The path at which to place the resulting collage image.</param>
 71    /// <param name="width">The desired width of the collage.</param>
 72    /// <param name="height">The desired height of the collage.</param>
 73    public void BuildSquareCollage(IReadOnlyList<string> paths, string outputPath, int width, int height)
 74    {
 075        using var bitmap = BuildSquareCollageBitmap(paths, width, height);
 076        using var outputStream = new SKFileWStream(outputPath);
 077        using var pixmap = new SKPixmap(new SKImageInfo(width, height), bitmap.GetPixels());
 078        pixmap.Encode(outputStream, GetEncodedFormat(outputPath), 90);
 079    }
 80
 81    /// <summary>
 82    /// Create a thumb collage.
 83    /// </summary>
 84    /// <param name="paths">The paths of the images to use in the collage.</param>
 85    /// <param name="outputPath">The path at which to place the resulting image.</param>
 86    /// <param name="width">The desired width of the collage.</param>
 87    /// <param name="height">The desired height of the collage.</param>
 88    /// <param name="libraryName">The name of the library to draw on the collage.</param>
 89    public void BuildThumbCollage(IReadOnlyList<string> paths, string outputPath, int width, int height, string? library
 90    {
 091        using var bitmap = BuildThumbCollageBitmap(paths, width, height, libraryName);
 092        using var outputStream = new SKFileWStream(outputPath);
 093        using var pixmap = new SKPixmap(new SKImageInfo(width, height), bitmap.GetPixels());
 094        pixmap.Encode(outputStream, GetEncodedFormat(outputPath), 90);
 095    }
 96
 97    private SKBitmap BuildThumbCollageBitmap(IReadOnlyList<string> paths, int width, int height, string? libraryName)
 98    {
 099        var bitmap = new SKBitmap(width, height);
 100
 0101        using var canvas = new SKCanvas(bitmap);
 0102        canvas.Clear(SKColors.Black);
 103
 0104        using var backdrop = SkiaHelper.GetNextValidImage(_skiaEncoder, paths, 0, out _);
 0105        if (backdrop is null)
 106        {
 0107            return bitmap;
 108        }
 109
 110        // resize to the same aspect as the original
 0111        var backdropHeight = Math.Abs(width * backdrop.Height / backdrop.Width);
 0112        using var resizedBackdrop = SkiaEncoder.ResizeImage(backdrop, new SKImageInfo(width, backdropHeight, backdrop.Co
 0113        using var paint = new SKPaint();
 0114        paint.FilterQuality = SKFilterQuality.High;
 115        // draw the backdrop
 0116        canvas.DrawImage(resizedBackdrop, 0, 0, paint);
 117
 118        // draw shadow rectangle
 0119        using var paintColor = new SKPaint
 0120        {
 0121            Color = SKColors.Black.WithAlpha(0x78),
 0122            Style = SKPaintStyle.Fill,
 0123            FilterQuality = SKFilterQuality.High
 0124        };
 0125        canvas.DrawRect(0, 0, width, height, paintColor);
 126
 0127        var typeFace = SkiaEncoder.DefaultTypeFace;
 128
 129        // draw library name
 0130        using var textPaint = new SKPaint
 0131        {
 0132            Color = SKColors.White,
 0133            Style = SKPaintStyle.Fill,
 0134            TextSize = 112,
 0135            TextAlign = SKTextAlign.Left,
 0136            Typeface = typeFace,
 0137            IsAntialias = true,
 0138            FilterQuality = SKFilterQuality.High
 0139        };
 140
 141        // scale down text to 90% of the width if text is larger than 95% of the width
 0142        var textWidth = textPaint.MeasureText(libraryName);
 0143        if (textWidth > width * 0.95)
 144        {
 0145            textPaint.TextSize = 0.9f * width * textPaint.TextSize / textWidth;
 146        }
 147
 0148        if (string.IsNullOrWhiteSpace(libraryName))
 149        {
 0150            return bitmap;
 151        }
 152
 0153        var realWidth = DrawText(null, 0, (height / 2f) + (textPaint.FontMetrics.XHeight / 2), libraryName, textPaint);
 0154        if (realWidth > width * 0.95)
 155        {
 0156            textPaint.TextSize = 0.9f * width * textPaint.TextSize / realWidth;
 0157            realWidth = DrawText(null, 0, (height / 2f) + (textPaint.FontMetrics.XHeight / 2), libraryName, textPaint);
 158        }
 159
 0160        var padding = (width - realWidth) / 2;
 161
 0162        if (IsRtlTextRegex().IsMatch(libraryName))
 163        {
 0164            textPaint.TextAlign = SKTextAlign.Right;
 0165            DrawText(canvas, width - padding, (height / 2f) + (textPaint.FontMetrics.XHeight / 2), libraryName, textPain
 166        }
 167        else
 168        {
 0169            DrawText(canvas, padding, (height / 2f) + (textPaint.FontMetrics.XHeight / 2), libraryName, textPaint);
 170        }
 171
 0172        return bitmap;
 0173    }
 174
 175    private SKBitmap BuildSquareCollageBitmap(IReadOnlyList<string> paths, int width, int height)
 176    {
 0177        var bitmap = new SKBitmap(width, height);
 0178        var imageIndex = 0;
 0179        var cellWidth = width / 2;
 0180        var cellHeight = height / 2;
 181
 0182        using var canvas = new SKCanvas(bitmap);
 0183        for (var x = 0; x < 2; x++)
 184        {
 0185            for (var y = 0; y < 2; y++)
 186            {
 0187                using var currentBitmap = SkiaHelper.GetNextValidImage(_skiaEncoder, paths, imageIndex, out int newIndex
 0188                imageIndex = newIndex;
 189
 0190                if (currentBitmap is null)
 191                {
 0192                    continue;
 193                }
 194
 195                // Scale image
 0196                var imageInfo = new SKImageInfo(cellWidth, cellHeight, currentBitmap.ColorType, currentBitmap.AlphaType,
 0197                using var resizeImage = SkiaEncoder.ResizeImage(currentBitmap, imageInfo);
 0198                using var paint = new SKPaint();
 0199                paint.FilterQuality = SKFilterQuality.High;
 200
 201                // draw this image into the strip at the next position
 0202                var xPos = x * cellWidth;
 0203                var yPos = y * cellHeight;
 0204                canvas.DrawImage(resizeImage, xPos, yPos, paint);
 205            }
 206        }
 207
 0208        return bitmap;
 0209    }
 210
 211    /// <summary>
 212    /// Draw shaped text with given SKPaint.
 213    /// </summary>
 214    /// <param name="canvas">If not null, draw text to this canvas, otherwise only measure the text width.</param>
 215    /// <param name="x">x position of the canvas to draw text.</param>
 216    /// <param name="y">y position of the canvas to draw text.</param>
 217    /// <param name="text">The text to draw.</param>
 218    /// <param name="textPaint">The SKPaint to style the text.</param>
 219    /// <returns>The width of the text.</returns>
 220    private static float MeasureAndDrawText(SKCanvas? canvas, float x, float y, string text, SKPaint textPaint)
 221    {
 0222        var width = textPaint.MeasureText(text);
 0223        canvas?.DrawShapedText(text, x, y, textPaint);
 0224        return width;
 225    }
 226
 227    /// <summary>
 228    /// Draw shaped text with given SKPaint, search defined type faces to render as many texts as possible.
 229    /// </summary>
 230    /// <param name="canvas">If not null, draw text to this canvas, otherwise only measure the text width.</param>
 231    /// <param name="x">x position of the canvas to draw text.</param>
 232    /// <param name="y">y position of the canvas to draw text.</param>
 233    /// <param name="text">The text to draw.</param>
 234    /// <param name="textPaint">The SKPaint to style the text.</param>
 235    /// <param name="isRtl">If true, render from right to left.</param>
 236    /// <returns>The width of the text.</returns>
 237    private static float DrawText(SKCanvas? canvas, float x, float y, string text, SKPaint textPaint, bool isRtl = false
 238    {
 0239        float width = 0;
 240
 0241        if (textPaint.ContainsGlyphs(text))
 242        {
 243            // Current font can render all characters in text
 0244            return MeasureAndDrawText(canvas, x, y, text, textPaint);
 245        }
 246
 247        // Iterate over all text elements using TextElementEnumerator
 248        // We cannot use foreach here because a human-readable character (grapheme cluster) can be multiple code points
 249        // We cannot render character by character because glyphs do not always have same width
 250        // And the result will look very unnatural due to the width difference and missing natural spacing
 0251        var start = 0;
 0252        var enumerator = StringInfo.GetTextElementEnumerator(text);
 0253        while (enumerator.MoveNext())
 254        {
 255            bool notAtEnd;
 0256            var textElement = enumerator.GetTextElement();
 0257            if (textPaint.ContainsGlyphs(textElement))
 258            {
 259                continue;
 260            }
 261
 262            // If we get here, we have a text element which cannot be rendered with current font
 263            // Draw previous characters which can be rendered with current font
 0264            if (start != enumerator.ElementIndex)
 265            {
 0266                var regularText = text.Substring(start, enumerator.ElementIndex - start);
 0267                width += MeasureAndDrawText(canvas, MoveX(x, width), y, regularText, textPaint);
 0268                start = enumerator.ElementIndex;
 269            }
 270
 271            // Search for next point where current font can render the character there
 0272            while ((notAtEnd = enumerator.MoveNext()) && !textPaint.ContainsGlyphs(enumerator.GetTextElement()))
 273            {
 274                // Do nothing, just move enumerator to the point where current font can render the character
 275            }
 276
 277            // Now we have a substring that should pick another font
 278            // The enumerator may or may not be already at the end of the string
 0279            var subtext = notAtEnd
 0280                ? text.Substring(start, enumerator.ElementIndex - start)
 0281                : text[start..];
 282
 0283            var fallback = SkiaEncoder.GetFontForCharacter(textElement);
 284
 0285            if (fallback is not null)
 286            {
 0287                using var fallbackTextPaint = new SKPaint();
 0288                fallbackTextPaint.Color = textPaint.Color;
 0289                fallbackTextPaint.Style = textPaint.Style;
 0290                fallbackTextPaint.TextSize = textPaint.TextSize;
 0291                fallbackTextPaint.TextAlign = textPaint.TextAlign;
 0292                fallbackTextPaint.Typeface = fallback;
 0293                fallbackTextPaint.IsAntialias = textPaint.IsAntialias;
 294
 295                // Do the search recursively to select all possible fonts
 0296                width += DrawText(canvas, MoveX(x, width), y, subtext, fallbackTextPaint, isRtl);
 297            }
 298            else
 299            {
 300                // Used up all fonts and no fonts can be found, just use current font
 0301                width += MeasureAndDrawText(canvas, MoveX(x, width), y, text[start..], textPaint);
 302            }
 303
 0304            start = notAtEnd ? enumerator.ElementIndex : text.Length;
 305        }
 306
 307        // Render the remaining text that current fonts can render
 0308        if (start < text.Length)
 309        {
 0310            width += MeasureAndDrawText(canvas, MoveX(x, width), y, text[start..], textPaint);
 311        }
 312
 0313        return width;
 314        float MoveX(float currentX, float dWidth) => isRtl ? currentX - dWidth : currentX + dWidth;
 315    }
 316}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:59 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Jellyfin.Drawing.Skia.SkiaEncoder)
GetEncodedFormat(System.String)
BuildSquareCollage(System.Collections.Generic.IReadOnlyList`1<System.String>,System.String,System.Int32,System.Int32)
BuildThumbCollage(System.Collections.Generic.IReadOnlyList`1<System.String>,System.String,System.Int32,System.Int32,System.String)
BuildThumbCollageBitmap(System.Collections.Generic.IReadOnlyList`1<System.String>,System.Int32,System.Int32,System.String)
BuildSquareCollageBitmap(System.Collections.Generic.IReadOnlyList`1<System.String>,System.Int32,System.Int32)
MeasureAndDrawText(SkiaSharp.SKCanvas,System.Single,System.Single,System.String,SkiaSharp.SKPaint)
DrawText(SkiaSharp.SKCanvas,System.Single,System.Single,System.String,SkiaSharp.SKPaint,System.Boolean)