v10: Update to ImageSharp v2

src/Umbraco.Core/Configuration/Models/ContentImagingSettings.cs

@@ -23,7 +23,7 @@ public class ContentImagingSettings
             }
         };
 
-        internal const string StaticImageFileTypes = "jpeg,jpg,gif,bmp,png,tiff,tif";
+        internal const string StaticImageFileTypes = "jpeg,jpg,gif,bmp,png,tiff,tif,webp";
 
         /// <summary>
         /// Gets or sets a value for the collection of accepted image file extensions.

src/Umbraco.Core/Configuration/Models/ImagingCacheSettings.cs

@@ -14,8 +14,9 @@ public class ImagingCacheSettings
     {
         internal const string StaticBrowserMaxAge = "7.00:00:00";
         internal const string StaticCacheMaxAge = "365.00:00:00";
-        internal const int StaticCachedNameLength = 8;
-        internal const string StaticCacheFolder = Constants.SystemDirectories.TempData +  "/MediaCache";
+        internal const int StaticCacheHashLength = 12;
+        internal const int StaticCacheFolderDepth = 8;
+        internal const string StaticCacheFolder = Constants.SystemDirectories.TempData + "/MediaCache";
 
         /// <summary>
         /// Gets or sets a value for the browser image cache maximum age.
@@ -30,13 +31,19 @@ public class ImagingCacheSettings
         public TimeSpan CacheMaxAge { get; set; } = TimeSpan.Parse(StaticCacheMaxAge);
 
         /// <summary>
-        /// Gets or sets a value for length of the cached name.
+        /// Gets or sets a value for the image cache hash length.
         /// </summary>
-        [DefaultValue(StaticCachedNameLength)]
-        public uint CachedNameLength { get; set; } = StaticCachedNameLength;
+        [DefaultValue(StaticCacheHashLength)]
+        public uint CacheHashLength { get; set; } = StaticCacheHashLength;
 
         /// <summary>
-        /// Gets or sets a value for the cache folder.
+        /// Gets or sets a value for the image cache folder depth.
+        /// </summary>
+        [DefaultValue(StaticCacheFolderDepth)]
+        public uint CacheFolderDepth { get; set; } = StaticCacheFolderDepth;
+
+        /// <summary>
+        /// Gets or sets a value for the image cache folder.
         /// </summary>
         [DefaultValue(StaticCacheFolder)]
         public string CacheFolder { get; set; } = StaticCacheFolder;

src/Umbraco.Core/Models/ImageUrlGenerationOptions.cs

@@ -1,9 +1,12 @@
+using System;
+using System.Collections.Generic;
+
 namespace Umbraco.Cms.Core.Models
 {
     /// <summary>
     /// These are options that are passed to the IImageUrlGenerator implementation to determine the URL that is generated.
     /// </summary>
-    public class ImageUrlGenerationOptions
+    public class ImageUrlGenerationOptions : IEquatable<ImageUrlGenerationOptions>
     {
         public ImageUrlGenerationOptions(string? imageUrl) => ImageUrl = imageUrl;
 
@@ -27,10 +30,43 @@ public class ImageUrlGenerationOptions
 
         public string? FurtherOptions { get; set; }
 
+        public override bool Equals(object? obj) => Equals(obj as ImageUrlGenerationOptions);
+
+        public bool Equals(ImageUrlGenerationOptions? other)
+            => other != null &&
+            ImageUrl == other.ImageUrl &&
+            Width == other.Width &&
+            Height == other.Height &&
+            Quality == other.Quality &&
+            ImageCropMode == other.ImageCropMode &&
+            ImageCropAnchor == other.ImageCropAnchor &&
+            EqualityComparer<FocalPointPosition>.Default.Equals(FocalPoint, other.FocalPoint) &&
+            EqualityComparer<CropCoordinates>.Default.Equals(Crop, other.Crop) &&
+            CacheBusterValue == other.CacheBusterValue &&
+            FurtherOptions == other.FurtherOptions;
+
+        public override int GetHashCode()
+        {
+            var hash = new HashCode();
+
+            hash.Add(ImageUrl);
+            hash.Add(Width);
+            hash.Add(Height);
+            hash.Add(Quality);
+            hash.Add(ImageCropMode);
+            hash.Add(ImageCropAnchor);
+            hash.Add(FocalPoint);
+            hash.Add(Crop);
+            hash.Add(CacheBusterValue);
+            hash.Add(FurtherOptions);
+
+            return hash.ToHashCode();
+        }
+
         /// <summary>
         /// The focal point position, in whatever units the registered IImageUrlGenerator uses, typically a percentage of the total image from 0.0 to 1.0.
         /// </summary>
-        public class FocalPointPosition
+        public class FocalPointPosition : IEquatable<FocalPointPosition>
         {
             public FocalPointPosition(decimal left, decimal top)
             {
@@ -41,12 +77,21 @@ public FocalPointPosition(decimal left, decimal top)
             public decimal Left { get; }
 
             public decimal Top { get; }
+
+            public override bool Equals(object? obj) => Equals(obj as FocalPointPosition);
+
+            public bool Equals(FocalPointPosition? other)
+                => other != null &&
+                Left == other.Left &&
+                Top == other.Top;
+
+            public override int GetHashCode() => HashCode.Combine(Left, Top);
         }
 
         /// <summary>
         /// The bounds of the crop within the original image, in whatever units the registered IImageUrlGenerator uses, typically a percentage between 0.0 and 1.0.
         /// </summary>
-        public class CropCoordinates
+        public class CropCoordinates : IEquatable<CropCoordinates>
         {
             public CropCoordinates(decimal left, decimal top, decimal right, decimal bottom)
             {
@@ -63,6 +108,17 @@ public CropCoordinates(decimal left, decimal top, decimal right, decimal bottom)
             public decimal Right { get; }
 
             public decimal Bottom { get; }
+
+            public override bool Equals(object? obj) => Equals(obj as CropCoordinates);
+
+            public bool Equals(CropCoordinates? other)
+                => other != null &&
+                Left == other.Left &&
+                Top == other.Top &&
+                Right == other.Right &&
+                Bottom == other.Bottom;
+
+            public override int GetHashCode() => HashCode.Combine(Left, Top, Right, Bottom);
         }
     }
 }

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs

@@ -200,7 +200,6 @@ public static IUmbracoBuilder AddCoreInitialServices(this IUmbracoBuilder builde
             // Add default ImageSharp configuration and service implementations
             builder.Services.AddSingleton(SixLabors.ImageSharp.Configuration.Default);
             builder.Services.AddSingleton<IImageDimensionExtractor, ImageSharpDimensionExtractor>();
-            builder.Services.AddSingleton<IImageUrlGenerator, ImageSharpImageUrlGenerator>();
 
             builder.Services.AddSingleton<PackageDataInstallation>();
 

src/Umbraco.Infrastructure/Media/ImageSharpDimensionExtractor.cs

@@ -1,5 +1,7 @@
+using System;
 using System.IO;
 using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using Umbraco.Cms.Core.Media;
 using Size = System.Drawing.Size;
 
@@ -30,10 +32,40 @@ public ImageSharpDimensionExtractor(Configuration configuration)
             IImageInfo imageInfo = Image.Identify(_configuration, stream);
             if (imageInfo != null)
             {
-                size = new Size(imageInfo.Width, imageInfo.Height);
+                size = IsExifOrientationRotated(imageInfo)
+                    ? new Size(imageInfo.Height, imageInfo.Width)
+                    : new Size(imageInfo.Width, imageInfo.Height);
             }
 
             return size;
         }
+
+        private static bool IsExifOrientationRotated(IImageInfo imageInfo)
+            => GetExifOrientation(imageInfo) switch
+            {
+                ExifOrientationMode.LeftTop
+                or ExifOrientationMode.RightTop
+                or ExifOrientationMode.RightBottom
+                or ExifOrientationMode.LeftBottom => true,
+                _ => false,
+            };
+
+        private static ushort GetExifOrientation(IImageInfo imageInfo)
+        {
+            IExifValue<ushort> orientation = imageInfo.Metadata.ExifProfile?.GetValue(ExifTag.Orientation);
+            if (orientation is not null)
+            {
+                if (orientation.DataType == ExifDataType.Short)
+                {
+                    return orientation.Value;
+                }
+                else
+                {
+                    return Convert.ToUInt16(orientation.Value);
+                }
+            }
+
+            return ExifOrientationMode.Unknown;
+        }
     }
 }

src/Umbraco.Infrastructure/Umbraco.Infrastructure.csproj

@@ -49,7 +49,7 @@
       <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />
       <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
       <PackageReference Include="Serilog.Sinks.Map" Version="1.0.2" />
-      <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
+      <PackageReference Include="SixLabors.ImageSharp" Version="2.1.1" />
       <PackageReference Include="System.IO.FileSystem.AccessControl" Version="5.0.0" />
       <PackageReference Include="System.Text.Encodings.Web" Version="6.0.0" /> <!-- Explicit updated this nested dependency due to this https://github.com/dotnet/announcements/issues/178-->
       <PackageReference Include="System.Threading.Tasks.Dataflow" Version="6.0.0" />