Ryujinx/Ryujinx.Graphics.Vic/Image/BufferPool.cs
gdkchan 4d02a2d2c0
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>
2020-07-12 05:07:01 +02:00

103 lines
3.2 KiB
C#

using System;
namespace Ryujinx.Graphics.Vic.Image
{
class BufferPool<T>
{
/// <summary>
/// Maximum number of buffers on the pool.
/// </summary>
private const int MaxBuffers = 4;
/// <summary>
/// Maximum size of a buffer that can be added on the pool.
/// If the required buffer is larger than this, it won't be
/// added to the pool to avoid long term high memory usage.
/// </summary>
private const int MaxBufferSize = 2048 * 1280;
private struct PoolItem
{
public bool InUse;
public T[] Buffer;
}
private readonly PoolItem[] _pool = new PoolItem[MaxBuffers];
/// <summary>
/// Rents a buffer with the exact size requested.
/// </summary>
/// <param name="length">Size of the buffer</param>
/// <param name="buffer">Span of the requested size</param>
/// <returns>The index of the buffer on the pool</returns>
public int Rent(int length, out Span<T> buffer)
{
int index = RentMinimum(length, out T[] bufferArray);
buffer = new Span<T>(bufferArray).Slice(0, length);
return index;
}
/// <summary>
/// Rents a buffer with a size greater than or equal to the requested size.
/// </summary>
/// <param name="length">Size of the buffer</param>
/// <param name="buffer">Array with a length greater than or equal to the requested length</param>
/// <returns>The index of the buffer on the pool</returns>
public int RentMinimum(int length, out T[] buffer)
{
if ((uint)length > MaxBufferSize)
{
buffer = new T[length];
return -1;
}
// Try to find a buffer that is larger or the same size of the requested one.
// This will avoid an allocation.
for (int i = 0; i < MaxBuffers; i++)
{
ref PoolItem item = ref _pool[i];
if (!item.InUse && item.Buffer != null && item.Buffer.Length >= length)
{
buffer = item.Buffer;
item.InUse = true;
return i;
}
}
buffer = new T[length];
// Try to add the new buffer to the pool.
// We try to find a slot that is not in use, and replace the buffer in it.
for (int i = 0; i < MaxBuffers; i++)
{
ref PoolItem item = ref _pool[i];
if (!item.InUse)
{
item.Buffer = buffer;
item.InUse = true;
return i;
}
}
return -1;
}
/// <summary>
/// Returns a buffer returned from <see cref="Rent(int)"/> to the pool.
/// </summary>
/// <param name="index">Index of the buffer on the pool</param>
public void Return(int index)
{
if (index < 0)
{
return;
}
_pool[index].InUse = false;
}
}
}