src/Ryujinx.Audio/Renderer/Server/Sink/CircularBufferSink.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

using Ryujinx.Audio.Renderer.Common;
using Ryujinx.Audio.Renderer.Parameter;
using Ryujinx.Audio.Renderer.Parameter.Sink;
using Ryujinx.Audio.Renderer.Server.MemoryPool;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Ryujinx.Audio.Renderer.Server.Sink
{
    /// <summary>
    /// Server information for a circular buffer sink.
    /// </summary>
    public class CircularBufferSink : BaseSink
    {
        /// <summary>
        /// The circular buffer parameter.
        /// </summary>
        public CircularBufferParameter Parameter;

        /// <summary>
        /// The last written data offset on the circular buffer.
        /// </summary>
        private uint _lastWrittenOffset;

        /// <summary>
        /// THe previous written offset of the circular buffer.
        /// </summary>
        private uint _oldWrittenOffset;

        /// <summary>
        /// The current offset to write data on the circular buffer.
        /// </summary>
        public uint CurrentWriteOffset { get; private set; }

        /// <summary>
        /// The <see cref="AddressInfo"/> of the circular buffer.
        /// </summary>
        public AddressInfo CircularBufferAddressInfo;

        public CircularBufferSink()
        {
            CircularBufferAddressInfo = AddressInfo.Create();
        }

        public override SinkType TargetSinkType => SinkType.CircularBuffer;

        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, in SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
        {
            errorInfo = new BehaviourParameter.ErrorInfo();
            outStatus = new SinkOutStatus();

            Debug.Assert(IsTypeValid(in parameter));

            ref CircularBufferParameter inputDeviceParameter = ref MemoryMarshal.Cast<byte, CircularBufferParameter>(parameter.SpecificData)[0];

            if (parameter.IsUsed != IsUsed || ShouldSkip)
            {
                UpdateStandardParameter(in parameter);

                if (parameter.IsUsed)
                {
                    Debug.Assert(CircularBufferAddressInfo.CpuAddress == 0);
                    Debug.Assert(CircularBufferAddressInfo.GetReference(false) == 0);

                    ShouldSkip = !mapper.TryAttachBuffer(out errorInfo, ref CircularBufferAddressInfo, inputDeviceParameter.BufferAddress, inputDeviceParameter.BufferSize);
                }
                else
                {
                    Debug.Assert(CircularBufferAddressInfo.CpuAddress != 0);
                    Debug.Assert(CircularBufferAddressInfo.GetReference(false) != 0);
                }

                Parameter = inputDeviceParameter;
            }

            outStatus.LastWrittenOffset = _lastWrittenOffset;
        }

        public override void UpdateForCommandGeneration()
        {
            Debug.Assert(Type == TargetSinkType);

            if (IsUsed)
            {
                uint frameSize = Constants.TargetSampleSize * Parameter.SampleCount * Parameter.InputCount;

                _lastWrittenOffset = _oldWrittenOffset;

                _oldWrittenOffset = CurrentWriteOffset;

                CurrentWriteOffset += frameSize;

                if (Parameter.BufferSize > 0)
                {
                    CurrentWriteOffset %= Parameter.BufferSize;
                }
            }
        }

        public override void CleanUp()
        {
            CircularBufferAddressInfo = AddressInfo.Create();
            _lastWrittenOffset = 0;
            _oldWrittenOffset = 0;
            CurrentWriteOffset = 0;
            base.CleanUp();
        }
    }
}