diff options
| author | gdkchan <gab.dark.100@gmail.com> | 2020-07-12 00:07:01 -0300 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2020-07-12 05:07:01 +0200 |
| commit | 4d02a2d2c0451b4de1f6de3bbce54c457cacebe2 (patch) | |
| tree | 120fe4fb8cfa1ac1c6ef4c97d92be47e955e8c0f /Ryujinx.Common/Memory/ArrayPtr.cs | |
| parent | 38b26cf4242999fa7d8c550993ac0940cd03d55f (diff) | |
New NVDEC and VIC implementation (#1384)
* Initial NVDEC and VIC implementation
* Update FFmpeg.AutoGen to 4.3.0
* Add nvdec dependencies for Windows
* Unify some VP9 structures
* Rename VP9 structure fields
* Improvements to Video API
* XML docs for Common.Memory
* Remove now unused or redundant overloads from MemoryAccessor
* NVDEC UV surface read/write scalar paths
* Add FIXME comments about hacky things/stuff that will need to be fixed in the future
* Cleaned up VP9 memory allocation
* Remove some debug logs
* Rename some VP9 structs
* Remove unused struct
* No need to compile Ryujinx.Graphics.Host1x with unsafe anymore
* Name AsyncWorkQueue threads to make debugging easier
* Make Vp9PictureInfo a ref struct
* LayoutConverter no longer needs the depth argument (broken by rebase)
* Pooling of VP9 buffers, plus fix a memory leak on VP9
* Really wish VS could rename projects properly...
* Address feedback
* Remove using
* Catch OperationCanceledException
* Add licensing informations
* Add THIRDPARTY.md to release too
Co-authored-by: Thog <me@thog.eu>
Diffstat (limited to 'Ryujinx.Common/Memory/ArrayPtr.cs')
| -rw-r--r-- | Ryujinx.Common/Memory/ArrayPtr.cs | 123 |
1 files changed, 123 insertions, 0 deletions
diff --git a/Ryujinx.Common/Memory/ArrayPtr.cs b/Ryujinx.Common/Memory/ArrayPtr.cs new file mode 100644 index 00000000..7a145de2 --- /dev/null +++ b/Ryujinx.Common/Memory/ArrayPtr.cs @@ -0,0 +1,123 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Ryujinx.Common.Memory +{ + /// <summary> + /// Represents an array of unmanaged resources. + /// </summary> + /// <typeparam name="T">Array element type</typeparam> + public unsafe struct ArrayPtr<T> : IEquatable<ArrayPtr<T>>, IArray<T> where T : unmanaged + { + private IntPtr _ptr; + + /// <summary> + /// Null pointer. + /// </summary> + public static ArrayPtr<T> Null => new ArrayPtr<T>() { _ptr = IntPtr.Zero }; + + /// <summary> + /// True if the pointer is null, false otherwise. + /// </summary> + public bool IsNull => _ptr == IntPtr.Zero; + + /// <summary> + /// Number of elements on the array. + /// </summary> + public int Length { get; } + + /// <summary> + /// Gets a reference to the item at the given index. + /// </summary> + /// <remarks> + /// No bounds checks are performed, this allows negative indexing, + /// but care must be taken if the index may be out of bounds. + /// </remarks> + /// <param name="index">Index of the element</param> + /// <returns>Reference to the element at the given index</returns> + public ref T this[int index] => ref Unsafe.AsRef<T>((T*)_ptr + index); + + /// <summary> + /// Creates a new array from a given reference. + /// </summary> + /// <remarks> + /// For data on the heap, proper pinning is necessary during + /// use. Failure to do so will result in memory corruption and crashes. + /// </remarks> + /// <param name="value">Reference of the first array element</param> + /// <param name="length">Number of elements on the array</param> + public ArrayPtr(ref T value, int length) + { + _ptr = (IntPtr)Unsafe.AsPointer(ref value); + Length = length; + } + + /// <summary> + /// Creates a new array from a given pointer. + /// </summary> + /// <param name="ptr">Array base pointer</param> + /// <param name="length">Number of elements on the array</param> + public ArrayPtr(T* ptr, int length) + { + _ptr = (IntPtr)ptr; + Length = length; + } + + /// <summary> + /// Creates a new array from a given pointer. + /// </summary> + /// <param name="ptr">Array base pointer</param> + /// <param name="length">Number of elements on the array</param> + public ArrayPtr(IntPtr ptr, int length) + { + _ptr = ptr; + Length = length; + } + + /// <summary> + /// Splits the array starting at the specified position. + /// </summary> + /// <param name="start">Index where the new array should start</param> + /// <returns>New array starting at the specified position</returns> + public ArrayPtr<T> Slice(int start) => new ArrayPtr<T>(ref this[start], Length - start); + + /// <summary> + /// Gets a span from the array. + /// </summary> + /// <returns>Span of the array</returns> + public Span<T> ToSpan() => Length == 0 ? Span<T>.Empty : MemoryMarshal.CreateSpan(ref this[0], Length); + + /// <summary> + /// Gets the array base pointer. + /// </summary> + /// <returns>Base pointer</returns> + public T* ToPointer() => (T*)_ptr; + + public override bool Equals(object obj) + { + return obj is ArrayPtr<T> other && Equals(other); + } + + public bool Equals([AllowNull] ArrayPtr<T> other) + { + return _ptr == other._ptr && Length == other.Length; + } + + public override int GetHashCode() + { + return HashCode.Combine(_ptr, Length); + } + + public static bool operator ==(ArrayPtr<T> left, ArrayPtr<T> right) + { + return left.Equals(right); + } + + public static bool operator !=(ArrayPtr<T> left, ArrayPtr<T> right) + { + return !(left == right); + } + } +} |