From 95f1f5a60a5778c62280783b79e64a9b030ac586 Mon Sep 17 00:00:00 2001
From: Sergio Pedri <sergio0694@live.com>
Date: Sun, 8 Nov 2020 13:06:28 +0100
Subject: [PATCH] Add unowned Image.WrapMemory(void*) overloads

---
 src/ImageSharp/Image.WrapMemory.cs            | 66 +++++++++++++++++++
 src/ImageSharp/Memory/ByteMemoryManager{T}.cs |  1 +
 .../Memory/UnmanagedMemoryManager{T}.cs       | 60 +++++++++++++++++
 3 files changed, 127 insertions(+)
 create mode 100644 src/ImageSharp/Memory/UnmanagedMemoryManager{T}.cs

diff --git a/src/ImageSharp/Image.WrapMemory.cs b/src/ImageSharp/Image.WrapMemory.cs
index d89c44dc56..b080c78887 100644
--- a/src/ImageSharp/Image.WrapMemory.cs
+++ b/src/ImageSharp/Image.WrapMemory.cs
@@ -220,5 +220,71 @@ namespace SixLabors.ImageSharp
             int height)
             where TPixel : unmanaged, IPixel<TPixel>
             => WrapMemory<TPixel>(Configuration.Default, byteMemory, width, height);
+
+        /// <summary>
+        /// Wraps an existing contiguous memory area of 'width' x 'height' pixels,
+        /// allowing to view/manipulate it as an <see cref="Image{TPixel}"/> instance.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel type</typeparam>
+        /// <param name="configuration">The <see cref="Configuration"/></param>
+        /// <param name="pointer">The pointer to the target memory buffer to wrap.</param>
+        /// <param name="width">The width of the memory image.</param>
+        /// <param name="height">The height of the memory image.</param>
+        /// <param name="metadata">The <see cref="ImageMetadata"/>.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The metadata is null.</exception>
+        /// <returns>An <see cref="Image{TPixel}"/> instance</returns>
+        public static unsafe Image<TPixel> WrapMemory<TPixel>(
+            Configuration configuration,
+            void* pointer,
+            int width,
+            int height,
+            ImageMetadata metadata)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Guard.NotNull(configuration, nameof(configuration));
+            Guard.NotNull(metadata, nameof(metadata));
+
+            var memoryManager = new UnmanagedMemoryManager<TPixel>(pointer, width * height);
+
+            var memorySource = MemoryGroup<TPixel>.Wrap(memoryManager.Memory);
+            return new Image<TPixel>(configuration, memorySource, width, height, metadata);
+        }
+
+        /// <summary>
+        /// Wraps an existing contiguous memory area of 'width' x 'height' pixels,
+        /// allowing to view/manipulate it as an <see cref="Image{TPixel}"/> instance.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel type</typeparam>
+        /// <param name="configuration">The <see cref="Configuration"/></param>
+        /// <param name="pointer">The pointer to the target memory buffer to wrap.</param>
+        /// <param name="width">The width of the memory image.</param>
+        /// <param name="height">The height of the memory image.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>An <see cref="Image{TPixel}"/> instance.</returns>
+        public static unsafe Image<TPixel> WrapMemory<TPixel>(
+            Configuration configuration,
+            void* pointer,
+            int width,
+            int height)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => WrapMemory<TPixel>(configuration, pointer, width, height, new ImageMetadata());
+
+        /// <summary>
+        /// Wraps an existing contiguous memory area of 'width' x 'height' pixels,
+        /// allowing to view/manipulate it as an <see cref="Image{TPixel}"/> instance.
+        /// The memory is being observed, the caller remains responsible for managing it's lifecycle.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel type.</typeparam>
+        /// <param name="pointer">The pointer to the target memory buffer to wrap.</param>
+        /// <param name="width">The width of the memory image.</param>
+        /// <param name="height">The height of the memory image.</param>
+        /// <returns>An <see cref="Image{TPixel}"/> instance.</returns>
+        public static unsafe Image<TPixel> WrapMemory<TPixel>(
+            void* pointer,
+            int width,
+            int height)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => WrapMemory<TPixel>(Configuration.Default, pointer, width, height);
     }
 }
diff --git a/src/ImageSharp/Memory/ByteMemoryManager{T}.cs b/src/ImageSharp/Memory/ByteMemoryManager{T}.cs
index 223709df65..1731639582 100644
--- a/src/ImageSharp/Memory/ByteMemoryManager{T}.cs
+++ b/src/ImageSharp/Memory/ByteMemoryManager{T}.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
+
 using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
diff --git a/src/ImageSharp/Memory/UnmanagedMemoryManager{T}.cs b/src/ImageSharp/Memory/UnmanagedMemoryManager{T}.cs
new file mode 100644
index 0000000000..58eaee320a
--- /dev/null
+++ b/src/ImageSharp/Memory/UnmanagedMemoryManager{T}.cs
@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+
+namespace SixLabors.ImageSharp.Memory
+{
+    /// <summary>
+    /// A custom <see cref="MemoryManager{T}"/> that can wrap a rawpointer to a buffer of a specified type.
+    /// </summary>
+    /// <typeparam name="T">The value type to use when casting the wrapped <see cref="Memory{T}"/> instance.</typeparam>
+    /// <remarks>This manager doesn't own the memory buffer that it points to.</remarks>
+    internal sealed unsafe class UnmanagedMemoryManager<T> : MemoryManager<T>
+        where T : unmanaged
+    {
+        /// <summary>
+        /// The pointer to the memory buffer.
+        /// </summary>
+        private readonly void* pointer;
+
+        /// <summary>
+        /// The length of the memory area.
+        /// </summary>
+        private readonly int length;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnmanagedMemoryManager{T}"/> class.
+        /// </summary>
+        /// <param name="pointer">The pointer to the memory buffer.</param>
+        /// <param name="length">The length of the memory area.</param>
+        public UnmanagedMemoryManager(void* pointer, int length)
+        {
+            this.pointer = pointer;
+            this.length = length;
+        }
+
+        /// <inheritdoc/>
+        protected override void Dispose(bool disposing)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override Span<T> GetSpan()
+        {
+            return new Span<T>(this.pointer, this.length);
+        }
+
+        /// <inheritdoc/>
+        public override MemoryHandle Pin(int elementIndex = 0)
+        {
+            return new MemoryHandle(((T*)this.pointer) + elementIndex);
+        }
+
+        /// <inheritdoc/>
+        public override void Unpin()
+        {
+        }
+    }
+}