Create a base class for the stream wrapper to make it possible to have a separate stream for async operations.

Author: dlemstra

src/Magick.NET/Helpers/StreamWrapper.cs

@@ -1,168 +1,43 @@
 // Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.IO;
-using System.Runtime.InteropServices;
 
 namespace ImageMagick;
 
-internal sealed unsafe class StreamWrapper : IDisposable
+internal sealed class StreamWrapper : StreamWrapperBase
 {
-    private const int BufferSize = 8192;
-
-    private readonly PooledByteArray _buffer;
-    private readonly byte* _bufferStart;
-    private readonly long _streamStart;
-    private readonly GCHandle _handle;
-    private Stream _stream;
+    private readonly Stream _stream;
 
     private StreamWrapper(Stream stream)
+        : base(stream)
     {
         _stream = stream;
-        _buffer = new PooledByteArray(BufferSize);
-        _handle = GCHandle.Alloc(_buffer.Data, GCHandleType.Pinned);
-        _bufferStart = (byte*)_handle.AddrOfPinnedObject().ToPointer();
-
-        try
-        {
-            _streamStart = _stream.Position;
-        }
-        catch
-        {
-            _streamStart = 0;
-        }
     }
 
     public static StreamWrapper CreateForReading(Stream stream)
     {
         Throw.IfFalse(stream.CanRead, nameof(stream), "The stream should be readable.");
 
-        return new StreamWrapper(stream);
+        return new(stream);
     }
 
     public static StreamWrapper CreateForWriting(Stream stream)
     {
         Throw.IfFalse(stream.CanWrite, nameof(stream), "The stream should be writable.");
 
-        return new StreamWrapper(stream);
-    }
-
-    public void Dispose()
-    {
-        _handle.Free();
-        _buffer.Dispose();
+        return new(stream);
     }
 
-    public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
-    {
-        var total = (long)count;
-        if (total == 0)
-            return 0;
-
-        if (data == IntPtr.Zero)
-            return 0;
-
-        var destination = (byte*)data.ToPointer();
-        long bytesRead = 0;
-
-        while (total > 0)
-        {
-            var length = Math.Min(total, BufferSize);
+    protected override int Read(int count)
+        => _stream.Read(Data, 0, count);
 
-            try
-            {
-                length = _stream.Read(_buffer.Data, 0, (int)length);
-            }
-            catch
-            {
-                return -1;
-            }
+    protected override long Seek(long offset, SeekOrigin origin)
+        => _stream.Seek(offset, origin);
 
-            if (length == 0)
-                break;
+    protected override long Tell()
+        => _stream.Position;
 
-            bytesRead += length;
-
-            destination = ReadBuffer(destination, length);
-
-            total -= length;
-        }
-
-        return bytesRead;
-    }
-
-    public long Seek(long offset, IntPtr whence, IntPtr user_data)
-    {
-        try
-        {
-            return (SeekOrigin)whence switch
-            {
-                SeekOrigin.Begin => _stream.Seek(_streamStart + offset, SeekOrigin.Begin) - _streamStart,
-                SeekOrigin.Current => _stream.Seek(offset, SeekOrigin.Current) - _streamStart,
-                SeekOrigin.End => _stream.Seek(offset, SeekOrigin.End) - _streamStart,
-                _ => -1,
-            };
-        }
-        catch
-        {
-            return -1;
-        }
-    }
-
-    public long Tell(IntPtr user_data)
-    {
-        try
-        {
-            return _stream.Position - _streamStart;
-        }
-        catch
-        {
-            return -1;
-        }
-    }
-
-    public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
-    {
-        var total = (long)count;
-        if (total == 0)
-            return 0;
-
-        if (data == IntPtr.Zero)
-            return 0;
-
-        var source = (byte*)data.ToPointer();
-
-        while (total > 0)
-        {
-            var length = Math.Min(total, BufferSize);
-
-            source = FillBuffer(source, length);
-
-            try
-            {
-                _stream.Write(_buffer.Data, 0, (int)length);
-            }
-            catch
-            {
-                return -1;
-            }
-
-            total -= length;
-        }
-
-        return (long)count;
-    }
-
-    private byte* FillBuffer(byte* source, long length)
-    {
-        NativeMemory.Copy(source, _bufferStart, length);
-        return source + length;
-    }
-
-    private byte* ReadBuffer(byte* destination, long length)
-    {
-        NativeMemory.Copy(_bufferStart, destination, length);
-        return destination + length;
-    }
+    protected override void Write(int count)
+        => _stream.Write(Data, 0, count);
 }

src/Magick.NET/Helpers/StreamWrapperBase.cs

@@ -0,0 +1,153 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace ImageMagick;
+
+internal abstract unsafe class StreamWrapperBase : IDisposable
+{
+    private const int BufferSize = 8192;
+
+    private readonly PooledByteArray _buffer;
+    private readonly GCHandle _handle;
+    private readonly byte* _bufferStart;
+    private readonly long _streamStart;
+
+    protected StreamWrapperBase(Stream stream)
+    {
+        _buffer = new PooledByteArray(BufferSize);
+        _handle = GCHandle.Alloc(_buffer.Data, GCHandleType.Pinned);
+        _bufferStart = (byte*)_handle.AddrOfPinnedObject().ToPointer();
+
+        try
+        {
+            _streamStart = stream.Position;
+        }
+        catch
+        {
+            _streamStart = 0;
+        }
+    }
+
+    protected byte[] Data
+        => _buffer.Data;
+
+    public void Dispose()
+    {
+        _handle.Free();
+        _buffer.Dispose();
+    }
+
+    public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
+    {
+        var total = (long)count;
+        if (total == 0)
+            return 0;
+
+        if (data == IntPtr.Zero)
+            return 0;
+
+        var destination = (byte*)data.ToPointer();
+        long bytesRead = 0;
+
+        while (total > 0)
+        {
+            var length = (int)Math.Min(total, BufferSize);
+
+            try
+            {
+                length = Read(length);
+                if (length == 0)
+                    break;
+
+                NativeMemory.Copy(_bufferStart, destination, length);
+            }
+            catch
+            {
+                return -1;
+            }
+
+            if (length == 0)
+                break;
+
+            bytesRead += length;
+            destination += length;
+            total -= length;
+        }
+
+        return bytesRead;
+    }
+
+    public long Seek(long offset, IntPtr whence, IntPtr user_data)
+    {
+        try
+        {
+            return (SeekOrigin)whence switch
+            {
+                SeekOrigin.Begin => Seek(_streamStart + offset, SeekOrigin.Begin) - _streamStart,
+                SeekOrigin.Current => Seek(offset, SeekOrigin.Current) - _streamStart,
+                SeekOrigin.End => Seek(offset, SeekOrigin.End) - _streamStart,
+                _ => -1,
+            };
+        }
+        catch
+        {
+            return -1;
+        }
+    }
+
+    public long Tell(IntPtr user_data)
+    {
+        try
+        {
+            return Tell() - _streamStart;
+        }
+        catch
+        {
+            return -1;
+        }
+    }
+
+    public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
+    {
+        var total = (long)count;
+        if (total == 0)
+            return 0;
+
+        if (data == IntPtr.Zero)
+            return 0;
+
+        var source = (byte*)data.ToPointer();
+
+        while (total > 0)
+        {
+            var length = (int)Math.Min(total, BufferSize);
+
+            try
+            {
+                NativeMemory.Copy(source, _bufferStart, length);
+                Write(length);
+            }
+            catch
+            {
+                return -1;
+            }
+
+            source += length;
+            total -= length;
+        }
+
+        return (long)count;
+    }
+
+    protected abstract int Read(int count);
+
+    protected abstract long Seek(long offset, SeekOrigin origin);
+
+    protected abstract long Tell();
+
+    protected abstract void Write(int count);
+}