aboutsummaryrefslogtreecommitdiff
path: root/src/Ryujinx.Audio/Renderer/Server/Splitter/SplitterDestinationVersion2.cs
blob: f9487909d40424faa772fc9202ab065b13327be6 (plain) (blame)
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
using Ryujinx.Audio.Renderer.Parameter;
using Ryujinx.Common.Memory;
using Ryujinx.Common.Utilities;
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace Ryujinx.Audio.Renderer.Server.Splitter
{
    /// <summary>
    /// Server state for a splitter destination (version 2).
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Size = 0x110, Pack = Alignment)]
    public struct SplitterDestinationVersion2
    {
        public const int Alignment = 0x10;

        /// <summary>
        /// The unique id of this <see cref="SplitterDestinationVersion2"/>.
        /// </summary>
        public int Id;

        /// <summary>
        /// The mix to output the result of the splitter.
        /// </summary>
        public int DestinationId;

        /// <summary>
        /// Mix buffer volumes storage.
        /// </summary>
        private MixArray _mix;
        private MixArray _previousMix;

        /// <summary>
        /// Pointer to the next linked element.
        /// </summary>
        private unsafe SplitterDestinationVersion2* _next;

        /// <summary>
        /// Set to true if in use.
        /// </summary>
        [MarshalAs(UnmanagedType.I1)]
        public bool IsUsed;

        /// <summary>
        /// Set to true if the internal state need to be updated.
        /// </summary>
        [MarshalAs(UnmanagedType.I1)]
        public bool NeedToUpdateInternalState;

        [StructLayout(LayoutKind.Sequential, Size = sizeof(float) * Constants.MixBufferCountMax, Pack = 1)]
        private struct MixArray { }

        /// <summary>
        /// Mix buffer volumes.
        /// </summary>
        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
        public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mix);

        /// <summary>
        /// Previous mix buffer volumes.
        /// </summary>
        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
        public Span<float> PreviousMixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _previousMix);

        /// <summary>
        /// Get the reference of the next element or null if not present.
        /// </summary>
        public readonly ref SplitterDestinationVersion2 Next
        {
            get
            {
                unsafe
                {
                    return ref Unsafe.AsRef<SplitterDestinationVersion2>(_next);
                }
            }
        }

        private Array2<BiquadFilterParameter> _biquadFilters;

        private Array2<bool> _isPreviousBiquadFilterEnabled;

        /// <summary>
        /// Create a new <see cref="SplitterDestinationVersion2"/>.
        /// </summary>
        /// <param name="id">The unique id of this <see cref="SplitterDestinationVersion2"/>.</param>
        public SplitterDestinationVersion2(int id) : this()
        {
            Id = id;
            DestinationId = Constants.UnusedMixId;

            ClearVolumes();
        }

        /// <summary>
        /// Update the <see cref="SplitterDestinationVersion2"/> from user parameter.
        /// </summary>
        /// <param name="parameter">The user parameter.</param>
        public void Update<T>(in T parameter) where T : ISplitterDestinationInParameter
        {
            Debug.Assert(Id == parameter.Id);

            if (parameter.IsMagicValid() && Id == parameter.Id)
            {
                DestinationId = parameter.DestinationId;

                parameter.MixBufferVolume.CopyTo(MixBufferVolume);

                _biquadFilters = parameter.BiquadFilters;

                if (!IsUsed && parameter.IsUsed)
                {
                    MixBufferVolume.CopyTo(PreviousMixBufferVolume);

                    NeedToUpdateInternalState = false;
                }

                IsUsed = parameter.IsUsed;
            }
        }

        /// <summary>
        /// Update the internal state of the instance.
        /// </summary>
        public void UpdateInternalState()
        {
            if (IsUsed && NeedToUpdateInternalState)
            {
                MixBufferVolume.CopyTo(PreviousMixBufferVolume);
            }

            NeedToUpdateInternalState = false;
        }

        /// <summary>
        /// Set the update internal state marker.
        /// </summary>
        public void MarkAsNeedToUpdateInternalState()
        {
            NeedToUpdateInternalState = true;
        }

        /// <summary>
        /// Return true if the <see cref="SplitterDestinationVersion2"/> is used and has a destination.
        /// </summary>
        /// <returns>True if the <see cref="SplitterDestinationVersion2"/> is used and has a destination.</returns>
        public readonly bool IsConfigured()
        {
            return IsUsed && DestinationId != Constants.UnusedMixId;
        }

        /// <summary>
        /// Get the volume for a given destination.
        /// </summary>
        /// <param name="destinationIndex">The destination index to use.</param>
        /// <returns>The volume for the given destination.</returns>
        public float GetMixVolume(int destinationIndex)
        {
            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);

            return MixBufferVolume[destinationIndex];
        }

        /// <summary>
        /// Get the previous volume for a given destination.
        /// </summary>
        /// <param name="destinationIndex">The destination index to use.</param>
        /// <returns>The volume for the given destination.</returns>
        public float GetMixVolumePrev(int destinationIndex)
        {
            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);

            return PreviousMixBufferVolume[destinationIndex];
        }

        /// <summary>
        /// Clear the volumes.
        /// </summary>
        public void ClearVolumes()
        {
            MixBufferVolume.Clear();
            PreviousMixBufferVolume.Clear();
        }

        /// <summary>
        /// Link the next element to the given <see cref="SplitterDestinationVersion2"/>.
        /// </summary>
        /// <param name="next">The given <see cref="SplitterDestinationVersion2"/> to link.</param>
        public void Link(ref SplitterDestinationVersion2 next)
        {
            unsafe
            {
                fixed (SplitterDestinationVersion2* nextPtr = &next)
                {
                    _next = nextPtr;
                }
            }
        }

        /// <summary>
        /// Remove the link to the next element.
        /// </summary>
        public void Unlink()
        {
            unsafe
            {
                _next = null;
            }
        }

        /// <summary>
        /// Checks if any biquad filter is enabled.
        /// </summary>
        /// <returns>True if any biquad filter is enabled.</returns>
        public bool IsBiquadFilterEnabled()
        {
            return _biquadFilters[0].Enable || _biquadFilters[1].Enable;
        }

        /// <summary>
        /// Checks if any biquad filter was previously enabled.
        /// </summary>
        /// <returns>True if any biquad filter was previously enabled.</returns>
        public bool IsBiquadFilterEnabledPrev()
        {
            return _isPreviousBiquadFilterEnabled[0];
        }

        /// <summary>
        /// Gets the biquad filter parameters.
        /// </summary>
        /// <param name="index">Biquad filter index (0 or 1).</param>
        /// <returns>Biquad filter parameters.</returns>
        public ref BiquadFilterParameter GetBiquadFilterParameter(int index)
        {
            return ref _biquadFilters[index];
        }

        /// <summary>
        /// Checks if any biquad filter was previously enabled.
        /// </summary>
        /// <param name="index">Biquad filter index (0 or 1).</param>
        public void UpdateBiquadFilterEnabledPrev(int index)
        {
            _isPreviousBiquadFilterEnabled[index] = _biquadFilters[index].Enable;
        }
    }
}