contiguous memory checking

Author: IS4Code

Diff for: SFI.Formats/Images/SharpImage.cs

@@ -132,18 +132,19 @@ public override Services.IImage Resize(int newWith, int newHeight, bool use32bpp
     public class SharpImageData<TPixel> : MemoryImageData<IImage> where TPixel : unmanaged, IPixel<TPixel>
     {
         readonly Image<TPixel> data;
-        readonly bool preferSlicing;
+
+        public override bool IsContiguous { get; }
 
         public SharpImageData(SharpImage image, Image<TPixel> data) : base(image, data.Width * Unsafe.SizeOf<TPixel>(), data.PixelType.BitsPerPixel)
         {
             this.data = data;
             // On contiguous buffers, the base implementation of GetPixel and GetRow is better since there is no MemoryManager allocation
-            preferSlicing = data.DangerousTryGetSinglePixelMemory(out _);
+            IsContiguous = data.DangerousTryGetSinglePixelMemory(out _);
         }
 
         public override Memory<byte> GetPixel(int x, int y)
         {
-            if(preferSlicing)
+            if(IsContiguous)
             {
                 return base.GetPixel(x, y);
             }
@@ -153,7 +154,7 @@ public override Memory<byte> GetPixel(int x, int y)
 
         public override Memory<byte> GetRow(int y)
         {
-            if(preferSlicing)
+            if(IsContiguous)
             {
                 return base.GetRow(y);
             }

Diff for: SFI/Services/IImage.cs

@@ -130,6 +130,13 @@ public interface IImage<TUnderlying> : IImage
     /// </summary>
     public interface IImageData : IMemoryOwner<byte>, IStreamFactory
     {
+        /// <summary>
+        /// Whether the image data is backed by a contiguous range of memory, in which
+        /// case the <see cref="IMemoryOwner{T}.Memory"/> member is usable and describable
+        /// by <see cref="Scan0"/> and <see cref="Stride"/>.
+        /// </summary>
+        bool IsContiguous { get; }
+
         /// <summary>
         /// The offset of the top-left pixel in the data.
         /// </summary>
@@ -348,6 +355,9 @@ public ImageData(ImageBase<TUnderlying> image)
 
         StreamFactoryAccess IStreamFactory.Access => StreamFactoryAccess.Parallel;
 
+        /// <inheritdoc/>
+        public abstract bool IsContiguous { get; }
+
         /// <inheritdoc/>
         public abstract int Scan0 { get; }
 
@@ -387,6 +397,9 @@ Stream IStreamFactory.Open()
 
     public abstract class MemoryImageData<TUnderlying> : ImageData<TUnderlying> where TUnderlying : class
     {
+        /// <inheritdoc/>
+        public override bool IsContiguous => true;
+
         /// <inheritdoc/>
         public override int Scan0 { get; }
 
@@ -430,9 +443,18 @@ public MemoryImageData(ImageBase<TUnderlying> image, int stride, int bitDepth) :
             RowSize = (Width * bitDepth + 7) / 8;
         }
 
+        private void CheckContiguous()
+        {
+            if(!IsContiguous)
+            {
+                throw new NotImplementedException("This operation is not implemented for non-contiguous memory.");
+            }
+        }
+
         /// <inheritdoc/>
         public override Memory<byte> GetPixel(int x, int y)
         {
+            CheckContiguous();
             var pixelSize = Math.DivRem(BitDepth, 8, out var rem);
             if(rem == 0)
             {
@@ -444,6 +466,7 @@ public override Memory<byte> GetPixel(int x, int y)
         /// <inheritdoc/>
         public override Memory<byte> GetRow(int y)
         {
+            CheckContiguous();
             return Memory.Slice(Scan0 + Stride * y, RowSize);
         }