Files
UmaViewer/Assets/Scripts/Audio/NAudio/Utils/CircularBuffer.cs
T
2022-09-10 16:59:44 +08:00

158 lines
4.8 KiB
C#

using System;
using System.Diagnostics;
namespace NAudio.Utils
{
/// <summary>
/// A very basic circular buffer implementation
/// </summary>
public class CircularBuffer
{
private readonly byte[] buffer;
private readonly object lockObject;
private int writePosition;
private int readPosition;
private int byteCount;
/// <summary>
/// Create a new circular buffer
/// </summary>
/// <param name="size">Max buffer size in bytes</param>
public CircularBuffer(int size)
{
buffer = new byte[size];
lockObject = new object();
}
/// <summary>
/// Write data to the buffer
/// </summary>
/// <param name="data">Data to write</param>
/// <param name="offset">Offset into data</param>
/// <param name="count">Number of bytes to write</param>
/// <returns>number of bytes written</returns>
public int Write(byte[] data, int offset, int count)
{
lock (lockObject)
{
var bytesWritten = 0;
if (count > buffer.Length - byteCount)
{
count = buffer.Length - byteCount;
}
// write to end
int writeToEnd = Math.Min(buffer.Length - writePosition, count);
Array.Copy(data, offset, buffer, writePosition, writeToEnd);
writePosition += writeToEnd;
writePosition %= buffer.Length;
bytesWritten += writeToEnd;
if (bytesWritten < count)
{
Debug.Assert(writePosition == 0);
// must have wrapped round. Write to start
Array.Copy(data, offset + bytesWritten, buffer, writePosition, count - bytesWritten);
writePosition += (count - bytesWritten);
bytesWritten = count;
}
byteCount += bytesWritten;
return bytesWritten;
}
}
/// <summary>
/// Read from the buffer
/// </summary>
/// <param name="data">Buffer to read into</param>
/// <param name="offset">Offset into read buffer</param>
/// <param name="count">Bytes to read</param>
/// <returns>Number of bytes actually read</returns>
public int Read(byte[] data, int offset, int count)
{
lock (lockObject)
{
if (count > byteCount)
{
count = byteCount;
}
int bytesRead = 0;
int readToEnd = Math.Min(buffer.Length - readPosition, count);
Array.Copy(buffer, readPosition, data, offset, readToEnd);
bytesRead += readToEnd;
readPosition += readToEnd;
readPosition %= buffer.Length;
if (bytesRead < count)
{
// must have wrapped round. Read from start
Debug.Assert(readPosition == 0);
Array.Copy(buffer, readPosition, data, offset + bytesRead, count - bytesRead);
readPosition += (count - bytesRead);
bytesRead = count;
}
byteCount -= bytesRead;
Debug.Assert(byteCount >= 0);
return bytesRead;
}
}
/// <summary>
/// Maximum length of this circular buffer
/// </summary>
public int MaxLength => buffer.Length;
/// <summary>
/// Number of bytes currently stored in the circular buffer
/// </summary>
public int Count
{
get
{
lock (lockObject)
{
return byteCount;
}
}
}
/// <summary>
/// Resets the buffer
/// </summary>
public void Reset()
{
lock (lockObject)
{
ResetInner();
}
}
private void ResetInner()
{
byteCount = 0;
readPosition = 0;
writePosition = 0;
}
/// <summary>
/// Advances the buffer, discarding bytes
/// </summary>
/// <param name="count">Bytes to advance</param>
public void Advance(int count)
{
lock (lockObject)
{
if (count >= byteCount)
{
ResetInner();
}
else
{
byteCount -= count;
readPosition += count;
readPosition %= MaxLength;
}
}
}
}
}