| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Globalization; |
| | | 4 | | using System.IO; |
| | | 5 | | using System.Linq; |
| | | 6 | | using BlurHashSharp.SkiaSharp; |
| | | 7 | | using Jellyfin.Extensions; |
| | | 8 | | using MediaBrowser.Common.Configuration; |
| | | 9 | | using MediaBrowser.Common.Extensions; |
| | | 10 | | using MediaBrowser.Controller.Drawing; |
| | | 11 | | using MediaBrowser.Model.Drawing; |
| | | 12 | | using Microsoft.Extensions.Logging; |
| | | 13 | | using SkiaSharp; |
| | | 14 | | using Svg.Skia; |
| | | 15 | | |
| | | 16 | | namespace Jellyfin.Drawing.Skia; |
| | | 17 | | |
| | | 18 | | /// <summary> |
| | | 19 | | /// Image encoder that uses <see cref="SkiaSharp"/> to manipulate images. |
| | | 20 | | /// </summary> |
| | | 21 | | public class SkiaEncoder : IImageEncoder |
| | | 22 | | { |
| | | 23 | | private const string SvgFormat = "svg"; |
| | 0 | 24 | | private static readonly HashSet<string> _transparentImageTypes = new(StringComparer.OrdinalIgnoreCase) { ".png", ".g |
| | | 25 | | private readonly ILogger<SkiaEncoder> _logger; |
| | | 26 | | private readonly IApplicationPaths _appPaths; |
| | 0 | 27 | | private static readonly SKTypeface?[] _typefaces = InitializeTypefaces(); |
| | 0 | 28 | | private static readonly SKImageFilter _imageFilter = SKImageFilter.CreateMatrixConvolution( |
| | 0 | 29 | | new SKSizeI(3, 3), |
| | 0 | 30 | | [ |
| | 0 | 31 | | 0, -.1f, 0, |
| | 0 | 32 | | -.1f, 1.4f, -.1f, |
| | 0 | 33 | | 0, -.1f, 0 |
| | 0 | 34 | | ], |
| | 0 | 35 | | 1f, |
| | 0 | 36 | | 0f, |
| | 0 | 37 | | new SKPointI(1, 1), |
| | 0 | 38 | | SKShaderTileMode.Clamp, |
| | 0 | 39 | | true); |
| | | 40 | | |
| | | 41 | | /// <summary> |
| | | 42 | | /// The default sampling options, equivalent to old high quality filter settings when upscaling. |
| | | 43 | | /// </summary> |
| | 0 | 44 | | public static readonly SKSamplingOptions UpscaleSamplingOptions = new SKSamplingOptions(SKCubicResampler.Mitchell); |
| | | 45 | | |
| | | 46 | | /// <summary> |
| | | 47 | | /// The sampling options, used for downscaling images, equivalent to old high quality filter settings when not upsca |
| | | 48 | | /// </summary> |
| | 0 | 49 | | public static readonly SKSamplingOptions DefaultSamplingOptions = new SKSamplingOptions(SKFilterMode.Linear, SKMipma |
| | | 50 | | |
| | | 51 | | /// <summary> |
| | | 52 | | /// Initializes a new instance of the <see cref="SkiaEncoder"/> class. |
| | | 53 | | /// </summary> |
| | | 54 | | /// <param name="logger">The application logger.</param> |
| | | 55 | | /// <param name="appPaths">The application paths.</param> |
| | | 56 | | public SkiaEncoder(ILogger<SkiaEncoder> logger, IApplicationPaths appPaths) |
| | | 57 | | { |
| | 21 | 58 | | _logger = logger; |
| | 21 | 59 | | _appPaths = appPaths; |
| | 21 | 60 | | } |
| | | 61 | | |
| | | 62 | | /// <inheritdoc/> |
| | 0 | 63 | | public string Name => "Skia"; |
| | | 64 | | |
| | | 65 | | /// <inheritdoc/> |
| | 0 | 66 | | public bool SupportsImageCollageCreation => true; |
| | | 67 | | |
| | | 68 | | /// <inheritdoc/> |
| | 0 | 69 | | public bool SupportsImageEncoding => true; |
| | | 70 | | |
| | | 71 | | /// <inheritdoc/> |
| | | 72 | | public IReadOnlyCollection<string> SupportedInputFormats => |
| | 0 | 73 | | new HashSet<string>(StringComparer.OrdinalIgnoreCase) |
| | 0 | 74 | | { |
| | 0 | 75 | | "jpeg", |
| | 0 | 76 | | "jpg", |
| | 0 | 77 | | "png", |
| | 0 | 78 | | "dng", |
| | 0 | 79 | | "webp", |
| | 0 | 80 | | "gif", |
| | 0 | 81 | | "bmp", |
| | 0 | 82 | | "ico", |
| | 0 | 83 | | "astc", |
| | 0 | 84 | | "ktx", |
| | 0 | 85 | | "pkm", |
| | 0 | 86 | | "wbmp", |
| | 0 | 87 | | // TODO: check if these are supported on multiple platforms |
| | 0 | 88 | | // https://github.com/google/skia/blob/master/infra/bots/recipes/test.py#L454 |
| | 0 | 89 | | // working on windows at least |
| | 0 | 90 | | "cr2", |
| | 0 | 91 | | "nef", |
| | 0 | 92 | | "arw", |
| | 0 | 93 | | SvgFormat |
| | 0 | 94 | | }; |
| | | 95 | | |
| | | 96 | | /// <inheritdoc/> |
| | | 97 | | public IReadOnlyCollection<ImageFormat> SupportedOutputFormats |
| | 0 | 98 | | => new HashSet<ImageFormat> { ImageFormat.Webp, ImageFormat.Jpg, ImageFormat.Png, ImageFormat.Svg }; |
| | | 99 | | |
| | | 100 | | /// <summary> |
| | | 101 | | /// Gets the default typeface to use. |
| | | 102 | | /// </summary> |
| | 0 | 103 | | public static SKTypeface? DefaultTypeFace => _typefaces.Last(); |
| | | 104 | | |
| | | 105 | | /// <summary> |
| | | 106 | | /// Check if the native lib is available. |
| | | 107 | | /// </summary> |
| | | 108 | | /// <returns>True if the native lib is available, otherwise false.</returns> |
| | | 109 | | public static bool IsNativeLibAvailable() |
| | | 110 | | { |
| | | 111 | | try |
| | | 112 | | { |
| | | 113 | | // test an operation that requires the native library |
| | 21 | 114 | | SKPMColor.PreMultiply(SKColors.Black); |
| | 21 | 115 | | return true; |
| | | 116 | | } |
| | 0 | 117 | | catch (Exception) |
| | | 118 | | { |
| | 0 | 119 | | return false; |
| | | 120 | | } |
| | 21 | 121 | | } |
| | | 122 | | |
| | | 123 | | /// <summary> |
| | | 124 | | /// Initialize the list of typefaces |
| | | 125 | | /// We have to statically build a list of typefaces because MatchCharacter only accepts a single character or code p |
| | | 126 | | /// But in reality a human-readable character (grapheme cluster) could be multiple code points. For example, 🚵🏻♀️ |
| | | 127 | | /// </summary> |
| | | 128 | | /// <returns>The list of typefaces.</returns> |
| | | 129 | | private static SKTypeface?[] InitializeTypefaces() |
| | | 130 | | { |
| | 0 | 131 | | int[] chars = [ |
| | 0 | 132 | | '鸡', // CJK Simplified Chinese |
| | 0 | 133 | | '雞', // CJK Traditional Chinese |
| | 0 | 134 | | 'ノ', // CJK Japanese |
| | 0 | 135 | | '각', // CJK Korean |
| | 0 | 136 | | 128169, // Emojis, 128169 is the Pile of Poo (💩) emoji |
| | 0 | 137 | | 'ז', // Hebrew |
| | 0 | 138 | | 'ي' // Arabic |
| | 0 | 139 | | ]; |
| | 0 | 140 | | var fonts = new List<SKTypeface>(chars.Length + 1); |
| | 0 | 141 | | foreach (var ch in chars) |
| | | 142 | | { |
| | 0 | 143 | | var font = SKFontManager.Default.MatchCharacter(null, SKFontStyleWeight.Bold, SKFontStyleWidth.Normal, SKFon |
| | 0 | 144 | | if (font is not null) |
| | | 145 | | { |
| | 0 | 146 | | fonts.Add(font); |
| | | 147 | | } |
| | | 148 | | } |
| | | 149 | | |
| | | 150 | | // Default font |
| | 0 | 151 | | fonts.Add(SKTypeface.FromFamilyName("sans-serif", SKFontStyleWeight.Bold, SKFontStyleWidth.Normal, SKFontStyleSl |
| | 0 | 152 | | ?? SKFontManager.Default.MatchCharacter(null, SKFontStyleWeight.Bold, SKFontStyleWidth.Normal, SKFontStyleSl |
| | | 153 | | |
| | 0 | 154 | | return fonts.ToArray(); |
| | | 155 | | } |
| | | 156 | | |
| | | 157 | | /// <summary> |
| | | 158 | | /// Convert a <see cref="ImageFormat"/> to a <see cref="SKEncodedImageFormat"/>. |
| | | 159 | | /// </summary> |
| | | 160 | | /// <param name="selectedFormat">The format to convert.</param> |
| | | 161 | | /// <returns>The converted format.</returns> |
| | | 162 | | public static SKEncodedImageFormat GetImageFormat(ImageFormat selectedFormat) |
| | | 163 | | { |
| | 0 | 164 | | return selectedFormat switch |
| | 0 | 165 | | { |
| | 0 | 166 | | ImageFormat.Bmp => SKEncodedImageFormat.Bmp, |
| | 0 | 167 | | ImageFormat.Jpg => SKEncodedImageFormat.Jpeg, |
| | 0 | 168 | | ImageFormat.Gif => SKEncodedImageFormat.Gif, |
| | 0 | 169 | | ImageFormat.Webp => SKEncodedImageFormat.Webp, |
| | 0 | 170 | | _ => SKEncodedImageFormat.Png |
| | 0 | 171 | | }; |
| | | 172 | | } |
| | | 173 | | |
| | | 174 | | /// <inheritdoc /> |
| | | 175 | | /// <exception cref="FileNotFoundException">The path is not valid.</exception> |
| | | 176 | | public ImageDimensions GetImageSize(string path) |
| | | 177 | | { |
| | 0 | 178 | | if (!File.Exists(path)) |
| | | 179 | | { |
| | 0 | 180 | | throw new FileNotFoundException("File not found", path); |
| | | 181 | | } |
| | | 182 | | |
| | 0 | 183 | | var extension = Path.GetExtension(path.AsSpan()); |
| | 0 | 184 | | if (extension.Equals(".svg", StringComparison.OrdinalIgnoreCase)) |
| | | 185 | | { |
| | 0 | 186 | | using var svg = new SKSvg(); |
| | | 187 | | try |
| | | 188 | | { |
| | 0 | 189 | | using var picture = svg.Load(path); |
| | 0 | 190 | | if (picture is null) |
| | | 191 | | { |
| | 0 | 192 | | _logger.LogError("Unable to determine image dimensions for {FilePath}", path); |
| | 0 | 193 | | return default; |
| | | 194 | | } |
| | | 195 | | |
| | 0 | 196 | | return new ImageDimensions(Convert.ToInt32(picture.CullRect.Width), Convert.ToInt32(picture.CullRect.Hei |
| | | 197 | | } |
| | 0 | 198 | | catch (FormatException skiaColorException) |
| | | 199 | | { |
| | | 200 | | // This exception is known to be thrown on vector images that define custom styles |
| | | 201 | | // Skia SVG is not able to handle that and as the repository is quite stale and has not received updates |
| | 0 | 202 | | _logger.LogDebug(skiaColorException, "There was a issue loading the requested svg file"); |
| | 0 | 203 | | return default; |
| | | 204 | | } |
| | | 205 | | } |
| | | 206 | | |
| | 0 | 207 | | var safePath = NormalizePath(path); |
| | 0 | 208 | | if (new FileInfo(safePath).Length == 0) |
| | | 209 | | { |
| | 0 | 210 | | _logger.LogDebug("Skip zero‑byte image {FilePath}", path); |
| | 0 | 211 | | return default; |
| | | 212 | | } |
| | | 213 | | |
| | 0 | 214 | | SKCodec? codec = null; |
| | 0 | 215 | | bool isSafePathTemp = !string.Equals(Path.GetFullPath(safePath), Path.GetFullPath(path), StringComparison.Ordina |
| | | 216 | | try |
| | | 217 | | { |
| | 0 | 218 | | codec = SKCodec.Create(safePath, out var result); |
| | 0 | 219 | | switch (result) |
| | | 220 | | { |
| | | 221 | | case SKCodecResult.Success: |
| | | 222 | | // Skia/SkiaSharp edge‑case: when the image header is parsed but the actual pixel |
| | | 223 | | // decode fails (truncated JPEG/PNG, exotic ICC/EXIF, CMYK without color‑transform, etc.) |
| | | 224 | | // `SKCodec.Create` returns a *non‑null* codec together with |
| | | 225 | | // SKCodecResult.InternalError. The header still contains valid dimensions, |
| | | 226 | | // which is all we need here – so we fall back to them instead of aborting. |
| | | 227 | | // See e.g. Skia bugs #4139, #6092. |
| | 0 | 228 | | case SKCodecResult.InternalError when codec is not null: |
| | 0 | 229 | | var info = codec.Info; |
| | 0 | 230 | | return new ImageDimensions(info.Width, info.Height); |
| | | 231 | | |
| | | 232 | | case SKCodecResult.Unimplemented: |
| | 0 | 233 | | _logger.LogDebug("Image format not supported: {FilePath}", path); |
| | 0 | 234 | | return default; |
| | | 235 | | |
| | | 236 | | default: |
| | | 237 | | { |
| | 0 | 238 | | var boundsInfo = SKBitmap.DecodeBounds(safePath); |
| | 0 | 239 | | if (boundsInfo.Width > 0 && boundsInfo.Height > 0) |
| | | 240 | | { |
| | 0 | 241 | | return new ImageDimensions(boundsInfo.Width, boundsInfo.Height); |
| | | 242 | | } |
| | | 243 | | |
| | 0 | 244 | | _logger.LogWarning( |
| | 0 | 245 | | "Unable to determine image dimensions for {FilePath}: {SkCodecResult}", |
| | 0 | 246 | | path, |
| | 0 | 247 | | result); |
| | | 248 | | |
| | 0 | 249 | | return default; |
| | | 250 | | } |
| | | 251 | | } |
| | | 252 | | } |
| | | 253 | | finally |
| | | 254 | | { |
| | | 255 | | try |
| | | 256 | | { |
| | 0 | 257 | | codec?.Dispose(); |
| | 0 | 258 | | } |
| | 0 | 259 | | catch (Exception ex) |
| | | 260 | | { |
| | 0 | 261 | | _logger.LogDebug(ex, "Error by closing codec for {FilePath}", safePath); |
| | 0 | 262 | | } |
| | | 263 | | |
| | 0 | 264 | | if (isSafePathTemp) |
| | | 265 | | { |
| | | 266 | | try |
| | | 267 | | { |
| | 0 | 268 | | if (File.Exists(safePath)) |
| | | 269 | | { |
| | 0 | 270 | | File.Delete(safePath); |
| | | 271 | | } |
| | 0 | 272 | | } |
| | 0 | 273 | | catch (Exception ex) |
| | | 274 | | { |
| | 0 | 275 | | _logger.LogDebug(ex, "Unable to remove temporary file '{TempPath}'", safePath); |
| | 0 | 276 | | } |
| | | 277 | | } |
| | 0 | 278 | | } |
| | 0 | 279 | | } |
| | | 280 | | |
| | | 281 | | /// <inheritdoc /> |
| | | 282 | | /// <exception cref="ArgumentNullException">The path is null.</exception> |
| | | 283 | | /// <exception cref="FileNotFoundException">The path is not valid.</exception> |
| | | 284 | | public string GetImageBlurHash(int xComp, int yComp, string path) |
| | | 285 | | { |
| | 0 | 286 | | ArgumentException.ThrowIfNullOrEmpty(path); |
| | | 287 | | |
| | 0 | 288 | | var extension = Path.GetExtension(path.AsSpan()).TrimStart('.'); |
| | 0 | 289 | | if (!SupportedInputFormats.Contains(extension, StringComparison.OrdinalIgnoreCase) |
| | 0 | 290 | | || extension.Equals(SvgFormat, StringComparison.OrdinalIgnoreCase)) |
| | | 291 | | { |
| | 0 | 292 | | _logger.LogDebug("Unable to compute blur hash due to unsupported format: {ImagePath}", path); |
| | 0 | 293 | | return string.Empty; |
| | | 294 | | } |
| | | 295 | | |
| | | 296 | | // Use FileStream with FileShare.Read instead of having Skia open the file to allow concurrent read access |
| | 0 | 297 | | using var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); |
| | | 298 | | // Any larger than 128x128 is too slow and there's no visually discernible difference |
| | 0 | 299 | | return BlurHashEncoder.Encode(xComp, yComp, fileStream, 128, 128); |
| | 0 | 300 | | } |
| | | 301 | | |
| | | 302 | | private bool RequiresSpecialCharacterHack(string path) |
| | | 303 | | { |
| | 0 | 304 | | for (int i = 0; i < path.Length; i++) |
| | | 305 | | { |
| | 0 | 306 | | if (char.GetUnicodeCategory(path[i]) == UnicodeCategory.OtherLetter) |
| | | 307 | | { |
| | 0 | 308 | | return true; |
| | | 309 | | } |
| | | 310 | | } |
| | | 311 | | |
| | 0 | 312 | | return path.HasDiacritics(); |
| | | 313 | | } |
| | | 314 | | |
| | | 315 | | private string NormalizePath(string path) |
| | | 316 | | { |
| | 0 | 317 | | if (!RequiresSpecialCharacterHack(path)) |
| | | 318 | | { |
| | 0 | 319 | | return path; |
| | | 320 | | } |
| | | 321 | | |
| | 0 | 322 | | var tempPath = Path.Join(_appPaths.TempDirectory, string.Concat("skia_", Guid.NewGuid().ToString(), Path.GetExte |
| | 0 | 323 | | var directory = Path.GetDirectoryName(tempPath) ?? throw new ResourceNotFoundException($"Provided path ({tempPat |
| | 0 | 324 | | Directory.CreateDirectory(directory); |
| | 0 | 325 | | File.Copy(path, tempPath, true); |
| | | 326 | | |
| | 0 | 327 | | return tempPath; |
| | | 328 | | } |
| | | 329 | | |
| | | 330 | | private static SKEncodedOrigin GetSKEncodedOrigin(ImageOrientation? orientation) |
| | | 331 | | { |
| | 0 | 332 | | if (!orientation.HasValue) |
| | | 333 | | { |
| | 0 | 334 | | return SKEncodedOrigin.Default; |
| | | 335 | | } |
| | | 336 | | |
| | 0 | 337 | | return (SKEncodedOrigin)orientation.Value; |
| | | 338 | | } |
| | | 339 | | |
| | | 340 | | /// <summary> |
| | | 341 | | /// Decode an image. |
| | | 342 | | /// </summary> |
| | | 343 | | /// <param name="path">The filepath of the image to decode.</param> |
| | | 344 | | /// <param name="forceCleanBitmap">Whether to force clean the bitmap.</param> |
| | | 345 | | /// <param name="orientation">The orientation of the image.</param> |
| | | 346 | | /// <param name="origin">The detected origin of the image.</param> |
| | | 347 | | /// <returns>The resulting bitmap of the image.</returns> |
| | | 348 | | internal SKBitmap? Decode(string path, bool forceCleanBitmap, ImageOrientation? orientation, out SKEncodedOrigin ori |
| | | 349 | | { |
| | 0 | 350 | | if (!File.Exists(path)) |
| | | 351 | | { |
| | 0 | 352 | | throw new FileNotFoundException("File not found", path); |
| | | 353 | | } |
| | | 354 | | |
| | 0 | 355 | | var requiresTransparencyHack = _transparentImageTypes.Contains(Path.GetExtension(path)); |
| | | 356 | | |
| | 0 | 357 | | if (requiresTransparencyHack || forceCleanBitmap) |
| | | 358 | | { |
| | 0 | 359 | | using SKCodec codec = SKCodec.Create(NormalizePath(path), out SKCodecResult res); |
| | 0 | 360 | | if (res != SKCodecResult.Success) |
| | | 361 | | { |
| | 0 | 362 | | origin = GetSKEncodedOrigin(orientation); |
| | 0 | 363 | | return null; |
| | | 364 | | } |
| | | 365 | | |
| | 0 | 366 | | if (codec.FrameCount != 0) |
| | | 367 | | { |
| | 0 | 368 | | throw new ArgumentException("Cannot decode images with multiple frames"); |
| | | 369 | | } |
| | | 370 | | |
| | | 371 | | // create the bitmap |
| | 0 | 372 | | SKBitmap? bitmap = null; |
| | | 373 | | try |
| | | 374 | | { |
| | 0 | 375 | | bitmap = new SKBitmap(codec.Info.Width, codec.Info.Height, !requiresTransparencyHack); |
| | | 376 | | |
| | | 377 | | // decode |
| | 0 | 378 | | _ = codec.GetPixels(bitmap.Info, bitmap.GetPixels()); |
| | | 379 | | |
| | 0 | 380 | | origin = codec.EncodedOrigin; |
| | | 381 | | |
| | 0 | 382 | | return bitmap!; |
| | | 383 | | } |
| | 0 | 384 | | catch (Exception e) |
| | | 385 | | { |
| | 0 | 386 | | _logger.LogError(e, "Detected intermediary error decoding image {0}", path); |
| | 0 | 387 | | bitmap?.Dispose(); |
| | 0 | 388 | | throw; |
| | | 389 | | } |
| | | 390 | | } |
| | | 391 | | |
| | 0 | 392 | | var resultBitmap = SKBitmap.Decode(NormalizePath(path)); |
| | | 393 | | |
| | 0 | 394 | | if (resultBitmap is null) |
| | | 395 | | { |
| | 0 | 396 | | return Decode(path, true, orientation, out origin); |
| | | 397 | | } |
| | | 398 | | |
| | | 399 | | try |
| | | 400 | | { |
| | | 401 | | // If we have to resize these they often end up distorted |
| | 0 | 402 | | if (resultBitmap.ColorType == SKColorType.Gray8) |
| | | 403 | | { |
| | 0 | 404 | | using (resultBitmap) |
| | | 405 | | { |
| | 0 | 406 | | return Decode(path, true, orientation, out origin); |
| | | 407 | | } |
| | | 408 | | } |
| | | 409 | | |
| | 0 | 410 | | origin = SKEncodedOrigin.TopLeft; |
| | 0 | 411 | | return resultBitmap; |
| | | 412 | | } |
| | 0 | 413 | | catch (Exception e) |
| | | 414 | | { |
| | 0 | 415 | | _logger.LogError(e, "Detected intermediary error decoding image {0}", path); |
| | 0 | 416 | | resultBitmap?.Dispose(); |
| | 0 | 417 | | throw; |
| | | 418 | | } |
| | 0 | 419 | | } |
| | | 420 | | |
| | | 421 | | private SKBitmap? GetBitmap(string path, bool autoOrient, ImageOrientation? orientation) |
| | | 422 | | { |
| | 0 | 423 | | if (autoOrient) |
| | | 424 | | { |
| | 0 | 425 | | var bitmap = Decode(path, true, orientation, out var origin); |
| | | 426 | | |
| | 0 | 427 | | if (bitmap is not null && origin != SKEncodedOrigin.TopLeft) |
| | | 428 | | { |
| | 0 | 429 | | using (bitmap) |
| | | 430 | | { |
| | 0 | 431 | | return OrientImage(bitmap, origin); |
| | | 432 | | } |
| | | 433 | | } |
| | | 434 | | |
| | 0 | 435 | | return bitmap; |
| | | 436 | | } |
| | | 437 | | |
| | 0 | 438 | | return Decode(path, false, orientation, out _); |
| | 0 | 439 | | } |
| | | 440 | | |
| | | 441 | | private SKBitmap? GetBitmapFromSvg(string path) |
| | | 442 | | { |
| | 0 | 443 | | if (!File.Exists(path)) |
| | | 444 | | { |
| | 0 | 445 | | throw new FileNotFoundException("File not found", path); |
| | | 446 | | } |
| | | 447 | | |
| | 0 | 448 | | using var svg = SKSvg.CreateFromFile(path); |
| | 0 | 449 | | if (svg.Drawable is null) |
| | | 450 | | { |
| | 0 | 451 | | return null; |
| | | 452 | | } |
| | | 453 | | |
| | 0 | 454 | | var width = (int)Math.Round(svg.Drawable.Bounds.Width); |
| | 0 | 455 | | var height = (int)Math.Round(svg.Drawable.Bounds.Height); |
| | | 456 | | |
| | 0 | 457 | | SKBitmap? bitmap = null; |
| | | 458 | | try |
| | | 459 | | { |
| | 0 | 460 | | bitmap = new SKBitmap(width, height); |
| | 0 | 461 | | using var canvas = new SKCanvas(bitmap); |
| | 0 | 462 | | canvas.DrawPicture(svg.Picture); |
| | 0 | 463 | | canvas.Flush(); |
| | 0 | 464 | | canvas.Save(); |
| | | 465 | | |
| | 0 | 466 | | return bitmap!; |
| | | 467 | | } |
| | 0 | 468 | | catch (Exception e) |
| | | 469 | | { |
| | 0 | 470 | | _logger.LogError(e, "Detected intermediary error extracting image {0}", path); |
| | 0 | 471 | | bitmap?.Dispose(); |
| | 0 | 472 | | throw; |
| | | 473 | | } |
| | 0 | 474 | | } |
| | | 475 | | |
| | | 476 | | private SKBitmap OrientImage(SKBitmap bitmap, SKEncodedOrigin origin) |
| | | 477 | | { |
| | 0 | 478 | | var needsFlip = origin is SKEncodedOrigin.LeftBottom or SKEncodedOrigin.LeftTop or SKEncodedOrigin.RightBottom o |
| | 0 | 479 | | SKBitmap? rotated = null; |
| | | 480 | | try |
| | | 481 | | { |
| | 0 | 482 | | rotated = needsFlip |
| | 0 | 483 | | ? new SKBitmap(bitmap.Height, bitmap.Width) |
| | 0 | 484 | | : new SKBitmap(bitmap.Width, bitmap.Height); |
| | 0 | 485 | | using var surface = new SKCanvas(rotated); |
| | 0 | 486 | | var midX = (float)rotated.Width / 2; |
| | 0 | 487 | | var midY = (float)rotated.Height / 2; |
| | | 488 | | |
| | | 489 | | switch (origin) |
| | | 490 | | { |
| | | 491 | | case SKEncodedOrigin.TopRight: |
| | 0 | 492 | | surface.Scale(-1, 1, midX, midY); |
| | 0 | 493 | | break; |
| | | 494 | | case SKEncodedOrigin.BottomRight: |
| | 0 | 495 | | surface.RotateDegrees(180, midX, midY); |
| | 0 | 496 | | break; |
| | | 497 | | case SKEncodedOrigin.BottomLeft: |
| | 0 | 498 | | surface.Scale(1, -1, midX, midY); |
| | 0 | 499 | | break; |
| | | 500 | | case SKEncodedOrigin.LeftTop: |
| | 0 | 501 | | surface.Translate(0, -rotated.Height); |
| | 0 | 502 | | surface.Scale(1, -1, midX, midY); |
| | 0 | 503 | | surface.RotateDegrees(-90); |
| | 0 | 504 | | break; |
| | | 505 | | case SKEncodedOrigin.RightTop: |
| | 0 | 506 | | surface.Translate(rotated.Width, 0); |
| | 0 | 507 | | surface.RotateDegrees(90); |
| | 0 | 508 | | break; |
| | | 509 | | case SKEncodedOrigin.RightBottom: |
| | 0 | 510 | | surface.Translate(rotated.Width, 0); |
| | 0 | 511 | | surface.Scale(1, -1, midX, midY); |
| | 0 | 512 | | surface.RotateDegrees(90); |
| | 0 | 513 | | break; |
| | | 514 | | case SKEncodedOrigin.LeftBottom: |
| | 0 | 515 | | surface.Translate(0, rotated.Height); |
| | 0 | 516 | | surface.RotateDegrees(-90); |
| | | 517 | | break; |
| | | 518 | | } |
| | | 519 | | |
| | 0 | 520 | | surface.DrawBitmap(bitmap, 0, 0, DefaultSamplingOptions); |
| | 0 | 521 | | return rotated; |
| | | 522 | | } |
| | 0 | 523 | | catch (Exception e) |
| | | 524 | | { |
| | 0 | 525 | | _logger.LogError(e, "Detected intermediary error rotating image"); |
| | 0 | 526 | | rotated?.Dispose(); |
| | 0 | 527 | | throw; |
| | | 528 | | } |
| | 0 | 529 | | } |
| | | 530 | | |
| | | 531 | | /// <summary> |
| | | 532 | | /// Resizes an image on the CPU, by utilizing a surface and canvas. |
| | | 533 | | /// |
| | | 534 | | /// The convolutional matrix kernel used in this resize function gives a (light) sharpening effect. |
| | | 535 | | /// This technique is similar to effect that can be created using for example the [Convolution matrix filter in GIMP |
| | | 536 | | /// </summary> |
| | | 537 | | /// <param name="source">The source bitmap.</param> |
| | | 538 | | /// <param name="targetInfo">This specifies the target size and other information required to create the surface.</p |
| | | 539 | | /// <param name="isAntialias">This enables anti-aliasing on the SKPaint instance.</param> |
| | | 540 | | /// <param name="isDither">This enables dithering on the SKPaint instance.</param> |
| | | 541 | | /// <returns>The resized image.</returns> |
| | | 542 | | internal static SKImage ResizeImage(SKBitmap source, SKImageInfo targetInfo, bool isAntialias = false, bool isDither |
| | | 543 | | { |
| | 0 | 544 | | using var surface = SKSurface.Create(targetInfo); |
| | 0 | 545 | | using var canvas = surface.Canvas; |
| | 0 | 546 | | using var paint = new SKPaint(); |
| | 0 | 547 | | paint.IsAntialias = isAntialias; |
| | 0 | 548 | | paint.IsDither = isDither; |
| | | 549 | | |
| | | 550 | | // Historically, kHigh implied cubic filtering, but only when upsampling. |
| | | 551 | | // If specified kHigh, and were down-sampling, Skia used to switch back to kMedium (bilinear filtering plus mipm |
| | | 552 | | // With current skia API, passing Mitchell cubic when down-sampling will cause serious quality degradation. |
| | 0 | 553 | | var samplingOptions = source.Width > targetInfo.Width || source.Height > targetInfo.Height |
| | 0 | 554 | | ? DefaultSamplingOptions |
| | 0 | 555 | | : UpscaleSamplingOptions; |
| | | 556 | | |
| | 0 | 557 | | paint.ImageFilter = _imageFilter; |
| | 0 | 558 | | canvas.DrawBitmap( |
| | 0 | 559 | | source, |
| | 0 | 560 | | SKRect.Create(0, 0, source.Width, source.Height), |
| | 0 | 561 | | SKRect.Create(0, 0, targetInfo.Width, targetInfo.Height), |
| | 0 | 562 | | samplingOptions, |
| | 0 | 563 | | paint); |
| | | 564 | | |
| | 0 | 565 | | return surface.Snapshot(); |
| | 0 | 566 | | } |
| | | 567 | | |
| | | 568 | | /// <inheritdoc/> |
| | | 569 | | public string EncodeImage(string inputPath, DateTime dateModified, string outputPath, bool autoOrient, ImageOrientat |
| | | 570 | | { |
| | 0 | 571 | | ArgumentException.ThrowIfNullOrEmpty(inputPath); |
| | 0 | 572 | | ArgumentException.ThrowIfNullOrEmpty(outputPath); |
| | | 573 | | |
| | 0 | 574 | | var inputFormat = Path.GetExtension(inputPath.AsSpan()).TrimStart('.'); |
| | 0 | 575 | | if (!SupportedInputFormats.Contains(inputFormat, StringComparison.OrdinalIgnoreCase)) |
| | | 576 | | { |
| | 0 | 577 | | _logger.LogDebug("Unable to encode image due to unsupported format: {ImagePath}", inputPath); |
| | 0 | 578 | | return inputPath; |
| | | 579 | | } |
| | | 580 | | |
| | 0 | 581 | | if (outputFormat == ImageFormat.Svg |
| | 0 | 582 | | && !inputFormat.Equals(SvgFormat, StringComparison.OrdinalIgnoreCase)) |
| | | 583 | | { |
| | 0 | 584 | | throw new ArgumentException($"Requested svg output from {inputFormat} input"); |
| | | 585 | | } |
| | | 586 | | |
| | 0 | 587 | | var skiaOutputFormat = GetImageFormat(outputFormat); |
| | | 588 | | |
| | 0 | 589 | | var hasBackgroundColor = !string.IsNullOrWhiteSpace(options.BackgroundColor); |
| | 0 | 590 | | var hasForegroundColor = !string.IsNullOrWhiteSpace(options.ForegroundLayer); |
| | 0 | 591 | | var blur = options.Blur ?? 0; |
| | 0 | 592 | | var hasIndicator = options.UnplayedCount.HasValue || !options.PercentPlayed.Equals(0); |
| | | 593 | | |
| | 0 | 594 | | using var bitmap = inputFormat.Equals(SvgFormat, StringComparison.OrdinalIgnoreCase) |
| | 0 | 595 | | ? GetBitmapFromSvg(inputPath) |
| | 0 | 596 | | : GetBitmap(inputPath, autoOrient, orientation); |
| | | 597 | | |
| | 0 | 598 | | if (bitmap is null) |
| | | 599 | | { |
| | 0 | 600 | | throw new InvalidDataException($"Skia unable to read image {inputPath}"); |
| | | 601 | | } |
| | | 602 | | |
| | 0 | 603 | | var originalImageSize = new ImageDimensions(bitmap.Width, bitmap.Height); |
| | | 604 | | |
| | 0 | 605 | | if (options.HasDefaultOptions(inputPath, originalImageSize) && !autoOrient) |
| | | 606 | | { |
| | | 607 | | // Just spit out the original file if all the options are default |
| | 0 | 608 | | return inputPath; |
| | | 609 | | } |
| | | 610 | | |
| | 0 | 611 | | var newImageSize = ImageHelper.GetNewImageSize(options, originalImageSize); |
| | | 612 | | |
| | 0 | 613 | | var width = newImageSize.Width; |
| | 0 | 614 | | var height = newImageSize.Height; |
| | | 615 | | |
| | | 616 | | // scale image (the FromImage creates a copy) |
| | 0 | 617 | | var imageInfo = new SKImageInfo(width, height, bitmap.ColorType, bitmap.AlphaType, bitmap.ColorSpace); |
| | 0 | 618 | | using var resizedImage = ResizeImage(bitmap, imageInfo); |
| | 0 | 619 | | using var resizedBitmap = SKBitmap.FromImage(resizedImage); |
| | | 620 | | |
| | | 621 | | // If all we're doing is resizing then we can stop now |
| | 0 | 622 | | if (!hasBackgroundColor && !hasForegroundColor && blur == 0 && !hasIndicator) |
| | | 623 | | { |
| | 0 | 624 | | var outputDirectory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({out |
| | 0 | 625 | | Directory.CreateDirectory(outputDirectory); |
| | 0 | 626 | | using var outputStream = new SKFileWStream(outputPath); |
| | 0 | 627 | | using var pixmap = new SKPixmap(new SKImageInfo(width, height), resizedBitmap.GetPixels()); |
| | 0 | 628 | | resizedBitmap.Encode(outputStream, skiaOutputFormat, quality); |
| | 0 | 629 | | return outputPath; |
| | | 630 | | } |
| | | 631 | | |
| | | 632 | | // create bitmap to use for canvas drawing used to draw into bitmap |
| | 0 | 633 | | using var saveBitmap = new SKBitmap(width, height); |
| | 0 | 634 | | using var canvas = new SKCanvas(saveBitmap); |
| | | 635 | | // set background color if present |
| | 0 | 636 | | if (hasBackgroundColor) |
| | | 637 | | { |
| | 0 | 638 | | canvas.Clear(SKColor.Parse(options.BackgroundColor)); |
| | | 639 | | } |
| | | 640 | | |
| | 0 | 641 | | using var paint = new SKPaint(); |
| | | 642 | | // Add blur if option is present |
| | 0 | 643 | | using var filter = blur > 0 ? SKImageFilter.CreateBlur(blur, blur) : null; |
| | 0 | 644 | | paint.ImageFilter = filter; |
| | | 645 | | |
| | | 646 | | // create image from resized bitmap to apply blur |
| | 0 | 647 | | canvas.DrawBitmap(resizedBitmap, SKRect.Create(width, height), DefaultSamplingOptions, paint); |
| | | 648 | | |
| | | 649 | | // If foreground layer present then draw |
| | 0 | 650 | | if (hasForegroundColor) |
| | | 651 | | { |
| | 0 | 652 | | if (!double.TryParse(options.ForegroundLayer, out double opacity)) |
| | | 653 | | { |
| | 0 | 654 | | opacity = .4; |
| | | 655 | | } |
| | | 656 | | |
| | 0 | 657 | | canvas.DrawColor(new SKColor(0, 0, 0, (byte)((1 - opacity) * 0xFF)), SKBlendMode.SrcOver); |
| | | 658 | | } |
| | | 659 | | |
| | 0 | 660 | | if (hasIndicator) |
| | | 661 | | { |
| | 0 | 662 | | DrawIndicator(canvas, width, height, options); |
| | | 663 | | } |
| | | 664 | | |
| | 0 | 665 | | var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) |
| | 0 | 666 | | Directory.CreateDirectory(directory); |
| | 0 | 667 | | using (var outputStream = new SKFileWStream(outputPath)) |
| | | 668 | | { |
| | 0 | 669 | | using var pixmap = new SKPixmap(new SKImageInfo(width, height), saveBitmap.GetPixels()); |
| | 0 | 670 | | pixmap.Encode(outputStream, skiaOutputFormat, quality); |
| | | 671 | | } |
| | | 672 | | |
| | 0 | 673 | | return outputPath; |
| | 0 | 674 | | } |
| | | 675 | | |
| | | 676 | | /// <inheritdoc/> |
| | | 677 | | public void CreateImageCollage(ImageCollageOptions options, string? libraryName) |
| | | 678 | | { |
| | 0 | 679 | | double ratio = (double)options.Width / options.Height; |
| | | 680 | | |
| | 0 | 681 | | if (ratio >= 1.4) |
| | | 682 | | { |
| | 0 | 683 | | new StripCollageBuilder(this).BuildThumbCollage(options.InputPaths, options.OutputPath, options.Width, optio |
| | | 684 | | } |
| | 0 | 685 | | else if (ratio >= .9) |
| | | 686 | | { |
| | 0 | 687 | | new StripCollageBuilder(this).BuildSquareCollage(options.InputPaths, options.OutputPath, options.Width, opti |
| | | 688 | | } |
| | | 689 | | else |
| | | 690 | | { |
| | | 691 | | // TODO: Create Poster collage capability |
| | 0 | 692 | | new StripCollageBuilder(this).BuildSquareCollage(options.InputPaths, options.OutputPath, options.Width, opti |
| | | 693 | | } |
| | 0 | 694 | | } |
| | | 695 | | |
| | | 696 | | /// <inheritdoc /> |
| | | 697 | | public void CreateSplashscreen(IReadOnlyList<string> posters, IReadOnlyList<string> backdrops) |
| | | 698 | | { |
| | | 699 | | // Only generate the splash screen if we have at least one poster and at least one backdrop/thumbnail. |
| | 16 | 700 | | if (posters.Count > 0 && backdrops.Count > 0) |
| | | 701 | | { |
| | 0 | 702 | | var splashBuilder = new SplashscreenBuilder(this, _logger); |
| | 0 | 703 | | var outputPath = Path.Combine(_appPaths.DataPath, "splashscreen.png"); |
| | 0 | 704 | | splashBuilder.GenerateSplash(posters, backdrops, outputPath); |
| | | 705 | | } |
| | 16 | 706 | | } |
| | | 707 | | |
| | | 708 | | /// <inheritdoc /> |
| | | 709 | | public int CreateTrickplayTile(ImageCollageOptions options, int quality, int imgWidth, int? imgHeight) |
| | | 710 | | { |
| | 0 | 711 | | var paths = options.InputPaths; |
| | 0 | 712 | | var tileWidth = options.Width; |
| | 0 | 713 | | var tileHeight = options.Height; |
| | | 714 | | |
| | 0 | 715 | | if (paths.Count < 1) |
| | | 716 | | { |
| | 0 | 717 | | throw new ArgumentException("InputPaths cannot be empty."); |
| | | 718 | | } |
| | 0 | 719 | | else if (paths.Count > tileWidth * tileHeight) |
| | | 720 | | { |
| | 0 | 721 | | throw new ArgumentException($"InputPaths contains more images than would fit on {tileWidth}x{tileHeight} gri |
| | | 722 | | } |
| | | 723 | | |
| | | 724 | | // If no height provided, use height of first image. |
| | 0 | 725 | | if (!imgHeight.HasValue) |
| | | 726 | | { |
| | 0 | 727 | | using var firstImg = Decode(paths[0], false, null, out _); |
| | | 728 | | |
| | 0 | 729 | | if (firstImg is null) |
| | | 730 | | { |
| | 0 | 731 | | throw new InvalidDataException("Could not decode image data."); |
| | | 732 | | } |
| | | 733 | | |
| | 0 | 734 | | if (firstImg.Width != imgWidth) |
| | | 735 | | { |
| | 0 | 736 | | throw new InvalidOperationException("Image width does not match provided width."); |
| | | 737 | | } |
| | | 738 | | |
| | 0 | 739 | | imgHeight = firstImg.Height; |
| | | 740 | | } |
| | | 741 | | |
| | | 742 | | // Make horizontal strips using every provided image. |
| | 0 | 743 | | using var tileGrid = new SKBitmap(imgWidth * tileWidth, imgHeight.Value * tileHeight); |
| | 0 | 744 | | using var canvas = new SKCanvas(tileGrid); |
| | | 745 | | |
| | 0 | 746 | | var imgIndex = 0; |
| | 0 | 747 | | for (var y = 0; y < tileHeight; y++) |
| | | 748 | | { |
| | 0 | 749 | | for (var x = 0; x < tileWidth; x++) |
| | | 750 | | { |
| | 0 | 751 | | if (imgIndex >= paths.Count) |
| | | 752 | | { |
| | | 753 | | break; |
| | | 754 | | } |
| | | 755 | | |
| | 0 | 756 | | using var img = Decode(paths[imgIndex++], false, null, out _); |
| | | 757 | | |
| | 0 | 758 | | if (img is null) |
| | | 759 | | { |
| | 0 | 760 | | throw new InvalidDataException("Could not decode image data."); |
| | | 761 | | } |
| | | 762 | | |
| | 0 | 763 | | if (img.Width != imgWidth) |
| | | 764 | | { |
| | 0 | 765 | | throw new InvalidOperationException("Image width does not match provided width."); |
| | | 766 | | } |
| | | 767 | | |
| | 0 | 768 | | if (img.Height != imgHeight) |
| | | 769 | | { |
| | 0 | 770 | | throw new InvalidOperationException("Image height does not match first image height."); |
| | | 771 | | } |
| | | 772 | | |
| | 0 | 773 | | canvas.DrawBitmap(img, x * imgWidth, y * imgHeight.Value, DefaultSamplingOptions); |
| | | 774 | | } |
| | | 775 | | } |
| | | 776 | | |
| | 0 | 777 | | using var outputStream = new SKFileWStream(options.OutputPath); |
| | 0 | 778 | | tileGrid.Encode(outputStream, SKEncodedImageFormat.Jpeg, quality); |
| | | 779 | | |
| | 0 | 780 | | return imgHeight.Value; |
| | 0 | 781 | | } |
| | | 782 | | |
| | | 783 | | private void DrawIndicator(SKCanvas canvas, int imageWidth, int imageHeight, ImageProcessingOptions options) |
| | | 784 | | { |
| | | 785 | | try |
| | | 786 | | { |
| | 0 | 787 | | var currentImageSize = new ImageDimensions(imageWidth, imageHeight); |
| | | 788 | | |
| | 0 | 789 | | if (options.UnplayedCount.HasValue) |
| | | 790 | | { |
| | 0 | 791 | | UnplayedCountIndicator.DrawUnplayedCountIndicator(canvas, currentImageSize, options.UnplayedCount.Value) |
| | | 792 | | } |
| | | 793 | | |
| | 0 | 794 | | if (options.PercentPlayed > 0) |
| | | 795 | | { |
| | 0 | 796 | | PercentPlayedDrawer.Process(canvas, currentImageSize, options.PercentPlayed); |
| | | 797 | | } |
| | 0 | 798 | | } |
| | 0 | 799 | | catch (Exception ex) |
| | | 800 | | { |
| | 0 | 801 | | _logger.LogError(ex, "Error drawing indicator overlay"); |
| | 0 | 802 | | } |
| | 0 | 803 | | } |
| | | 804 | | |
| | | 805 | | /// <summary> |
| | | 806 | | /// Return the typeface that contains the glyph for the given character. |
| | | 807 | | /// </summary> |
| | | 808 | | /// <param name="c">The text character.</param> |
| | | 809 | | /// <returns>The typeface contains the character.</returns> |
| | | 810 | | public static SKTypeface? GetFontForCharacter(string c) |
| | | 811 | | { |
| | 0 | 812 | | foreach (var typeface in _typefaces) |
| | | 813 | | { |
| | 0 | 814 | | if (typeface is not null && typeface.ContainsGlyphs(c)) |
| | | 815 | | { |
| | 0 | 816 | | return typeface; |
| | | 817 | | } |
| | | 818 | | } |
| | | 819 | | |
| | 0 | 820 | | return null; |
| | | 821 | | } |
| | | 822 | | } |