Version
menu
Wwise SDK 2025.1.0
AkSpeakerVolumes.h
Go to the documentation of this file.
1 /*******************************************************************************
2 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
3 released in source code form as part of the SDK installer package.
4 
5 Commercial License Usage
6 
7 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
8 may use this file in accordance with the end user license agreement provided
9 with the software or, alternatively, in accordance with the terms contained in a
10 written agreement between you and Audiokinetic Inc.
11 
12 Apache License Usage
13 
14 Alternatively, this file may be used under the Apache License, Version 2.0 (the
15 "Apache License"); you may not use this file except in compliance with the
16 Apache License. You may obtain a copy of the Apache License at
17 http://www.apache.org/licenses/LICENSE-2.0.
18 
19 Unless required by applicable law or agreed to in writing, software distributed
20 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
21 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
22 the specific language governing permissions and limitations under the License.
23 
24  Copyright (c) 2025 Audiokinetic Inc.
25 *******************************************************************************/
26 
27 // AkSpeakerVolumes.h
28 
29 /// \file
30 /// Multi-channel volume definitions and services.
31 /// Always associated with an AkChannelConfig. In the case of standard configurations, the volume items ordering
32 /// match the bit ordering in the channel mask, except for the LFE which is skipped and placed at the end of the
33 /// volume array.
34 /// See \ref goingfurther_speakermatrixcallback for an example of how to manipulate speaker volume vectors/matrices.
35 
36 #ifndef _AK_SPEAKER_VOLUMES_H_
37 #define _AK_SPEAKER_VOLUMES_H_
38 
39 #include <string.h>
40 #include <AK/SoundEngine/Common/AkTypes.h>
41 #include <AK/SoundEngine/Platforms/Generic/AkSpeakerVolumes.h>
42 
43 /// Copy volumes.
44 AkForceInline void AK_SpeakerVolumes_Vector_Copy(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
45 {
46  if (in_uNumChannels)
47  memcpy(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels * sizeof(AkReal32));
48 }
49 
50 /// Copy volumes with gain.
51 AkForceInline void AK_SpeakerVolumes_Vector_CopyAndApplyGain(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain)
52 {
53  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
54  {
55  in_pVolumesDst[uChan] = in_pVolumesSrc[uChan] * in_fGain;
56  }
57 }
58 
59 /// Clear volumes.
60 AkForceInline void AK_SpeakerVolumes_Vector_Zero(AkSpeakerVolumesVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
61 {
62  if (in_uNumChannels)
63  memset(in_pVolumes, 0, in_uNumChannels * sizeof(AkReal32));
64 }
65 
66 /// Accumulate two volume vectors.
67 AkForceInline void AK_SpeakerVolumes_Vector_Add(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
68 {
69  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
70  {
71  io_pVolumesDst[uChan] += in_pVolumesSrc[uChan];
72  }
73 }
74 
75 /// Compute the sum of all components of a volume vector.
76 AkForceInline AkReal32 AK_SpeakerVolumes_Vector_L1Norm(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
77 {
78  AkReal32 total = 0;
79  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
80  {
81  total += in_pVolumes[uChan];
82  }
83 
84  return total;
85 }
86 
87 /// Multiply volume vector with a scalar.
88 AkForceInline void AK_SpeakerVolumes_Vector_MulScalar(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannels)
89 {
90  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
91  {
92  in_pVolumesDst[uChan] *= in_fVol;
93  }
94 }
95 
96 /// Multiply two volume vectors.
97 AkForceInline void AK_SpeakerVolumes_Vector_Mul(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
98 {
99  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
100  {
101  in_pVolumesDst[uChan] *= in_pVolumesSrc[uChan];
102  }
103 }
104 
105 /// Get max for all elements of two volume vectors, independently.
106 AkForceInline void AK_SpeakerVolumes_Vector_Max(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
107 {
108  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
109  {
110  in_pVolumesDst[uChan] = AkMax(in_pVolumesDst[uChan], in_pVolumesSrc[uChan]);
111  }
112 }
113 
114 /// Get min for all elements of two volume vectors, independently.
115 AkForceInline void AK_SpeakerVolumes_Vector_Min(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
116 {
117  for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
118  {
119  in_pVolumesDst[uChan] = AkMin(in_pVolumesDst[uChan], in_pVolumesSrc[uChan]);
120  }
121 }
122 
123 /// Compute size (in bytes) required for given channel configurations.
124 AkForceInline AkUInt32 AK_SpeakerVolumes_Matrix_GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
125 {
126  return in_uNumChannelsIn * AK_SpeakerVolumes_Vector_GetRequiredSize(in_uNumChannelsOut);
127 }
128 
129 /// Compute size (in number of elements) required for given channel configurations.
130 AkForceInline AkUInt32 AK_SpeakerVolumes_Matrix_GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
131 {
132  return in_uNumChannelsIn * AK_SpeakerVolumes_Vector_GetNumElements(in_uNumChannelsOut);
133 }
134 
135 /// Get pointer to volume distribution for input channel in_uIdxChannelIn.
136 AkForceInline AkSpeakerVolumesVectorPtr AK_SpeakerVolumes_Matrix_GetChannel(AkSpeakerVolumesMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
137 {
138  return in_pVolumeMx + in_uIdxChannelIn * AK_SpeakerVolumes_Vector_GetNumElements(in_uNumChannelsOut);
139 }
140 AkForceInline AkSpeakerVolumesConstVectorPtr AK_SpeakerVolumes_Matrix_GetChannel_Const(AkSpeakerVolumesConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
141 {
142  return in_pVolumeMx + in_uIdxChannelIn * AK_SpeakerVolumes_Vector_GetNumElements(in_uNumChannelsOut);
143 }
144 
145 /// Copy matrix.
146 AkForceInline void AK_SpeakerVolumes_Matrix_Copy(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
147 {
148  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
149  if (uNumElements)
150  memcpy(in_pVolumesDst, in_pVolumesSrc, uNumElements * sizeof(AkReal32));
151 }
152 
153 /// Copy matrix with gain.
154 AkForceInline void AK_SpeakerVolumes_Matrix_CopyAndApplyGain(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
155 {
156  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
157  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
158  {
159  in_pVolumesDst[uChan] = in_pVolumesSrc[uChan] * in_fGain;
160  }
161 }
162 
163 /// Clear matrix.
164 AkForceInline void AK_SpeakerVolumes_Matrix_Zero(AkSpeakerVolumesMatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
165 {
166  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
167  if (uNumElements)
168  memset(in_pVolumes, 0, uNumElements * sizeof(AkReal32));
169 }
170 
171 /// Multiply a matrix with a scalar.
172 AkForceInline void AK_SpeakerVolumes_Matrix_Mul(AkSpeakerVolumesMatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
173 {
174  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
175  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
176  {
177  in_pVolumesDst[uChan] *= in_fVol;
178  }
179 }
180 
181 /// Add all elements of two volume matrices, independently.
182 AkForceInline void AK_SpeakerVolumes_Matrix_Add(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
183 {
184  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
185  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
186  {
187  in_pVolumesDst[uChan] += in_pVolumesSrc[uChan];
188  }
189 }
190 
191 /// Pointwise Multiply-Add of all elements of two volume matrices.
192 AkForceInline void AK_SpeakerVolumes_Matrix_MAdd(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
193 {
194  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
195  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
196  {
197  in_pVolumesDst[uChan] += in_pVolumesSrc[uChan] * in_fGain;
198  }
199 }
200 
201 /// Get absolute max for all elements of two volume matrices, independently.
202 AkForceInline void AK_SpeakerVolumes_Matrix_AbsMax(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
203 {
204  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
205  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
206  {
207  in_pVolumesDst[uChan] = ((in_pVolumesDst[uChan] * in_pVolumesDst[uChan]) > (in_pVolumesSrc[uChan] * in_pVolumesSrc[uChan])) ? in_pVolumesDst[uChan] : in_pVolumesSrc[uChan];
208 }
209  }
210 
211 /// Get max for all elements of two volume matrices, independently.
212 AkForceInline void AK_SpeakerVolumes_Matrix_Max(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
213 {
214  AkUInt32 uNumElements = AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
215  for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
216  {
217  in_pVolumesDst[uChan] = (in_pVolumesDst[uChan] > in_pVolumesSrc[uChan]) ? in_pVolumesDst[uChan] : in_pVolumesSrc[uChan];
218  }
219 }
220 
221 #ifdef __cplusplus
222 namespace AK
223 {
224 /// Multi-channel volume definitions and services.
225 namespace SpeakerVolumes
226 {
227  /// Volume vector services.
228  namespace Vector
229  {
230  AkForceInline void Copy(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
231  {
232  return AK_SpeakerVolumes_Vector_Copy(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels);
233  }
234  AkForceInline void Copy(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain)
235  {
236  return AK_SpeakerVolumes_Vector_CopyAndApplyGain(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels, in_fGain);
237  }
238  AkForceInline void Zero(AkSpeakerVolumesVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
239  {
240  return AK_SpeakerVolumes_Vector_Zero(in_pVolumes, in_uNumChannels);
241  }
242  AkForceInline void Add(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
243  {
244  return AK_SpeakerVolumes_Vector_Add(io_pVolumesDst, in_pVolumesSrc, in_uNumChannels);
245  }
246  AkForceInline AkReal32 L1Norm(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
247  {
248  return AK_SpeakerVolumes_Vector_L1Norm(in_pVolumes, in_uNumChannels);
249  }
250  AkForceInline void Mul( VectorPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannels )
251  {
252  return AK_SpeakerVolumes_Vector_MulScalar(in_pVolumesDst, in_fVol, in_uNumChannels);
253  }
254  AkForceInline void Mul( VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels )
255  {
256  return AK_SpeakerVolumes_Vector_Mul(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels);
257  }
258  AkForceInline void Max(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
259  {
260  return AK_SpeakerVolumes_Vector_Max(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels);
261  }
262  AkForceInline void Min(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
263  {
264  return AK_SpeakerVolumes_Vector_Min(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels);
265  }
266  }
267 
268  /// Volume matrix (multi-in/multi-out channel configurations) services.
269  namespace Matrix
270  {
271  AkForceInline AkUInt32 GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
272  {
273  return AK_SpeakerVolumes_Matrix_GetRequiredSize(in_uNumChannelsIn, in_uNumChannelsOut);
274  }
275  AkForceInline AkUInt32 GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
276  {
277  return AK_SpeakerVolumes_Matrix_GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
278  }
279  AkForceInline VectorPtr GetChannel( MatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut )
280  {
281  return AK_SpeakerVolumes_Matrix_GetChannel(in_pVolumeMx, in_uIdxChannelIn, in_uNumChannelsOut);
282  }
283  AkForceInline ConstVectorPtr GetChannel( ConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut )
284  {
285  return AK_SpeakerVolumes_Matrix_GetChannel_Const(in_pVolumeMx, in_uIdxChannelIn, in_uNumChannelsOut);
286  }
287  AkForceInline void Copy( MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut )
288  {
289  return AK_SpeakerVolumes_Matrix_Copy(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut);
290  }
291  AkForceInline void Copy( MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain )
292  {
293  return AK_SpeakerVolumes_Matrix_CopyAndApplyGain(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut, in_fGain);
294  }
295  AkForceInline void Zero(AkSpeakerVolumesMatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
296  {
297  return AK_SpeakerVolumes_Matrix_Zero(in_pVolumes, in_uNumChannelsIn, in_uNumChannelsOut);
298  }
299  AkForceInline void Mul(AkSpeakerVolumesMatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
300  {
301  return AK_SpeakerVolumes_Matrix_Mul(in_pVolumesDst, in_fVol, in_uNumChannelsIn, in_uNumChannelsOut);
302  }
303  AkForceInline void Add(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
304  {
305  return AK_SpeakerVolumes_Matrix_Add(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut);
306  }
307  AkForceInline void MAdd(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
308  {
309  return AK_SpeakerVolumes_Matrix_MAdd(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut, in_fGain);
310  }
311  AkForceInline void AbsMax(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
312  {
313  return AK_SpeakerVolumes_Matrix_AbsMax(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut);
314  }
315  AkForceInline void Max(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
316  {
317  return AK_SpeakerVolumes_Matrix_Max(in_pVolumesDst, in_pVolumesSrc, in_uNumChannelsIn, in_uNumChannelsOut);
318  }
319  }
320 }
321 }
322 #endif // __cplusplus
323 
324 #endif //_AK_SPEAKER_VOLUMES_H_
AK_SpeakerVolumes_Matrix_Zero
AkForceInline void AK_SpeakerVolumes_Matrix_Zero(AkSpeakerVolumesMatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Clear matrix.
Definition: AkSpeakerVolumes.h:164
AkMax
#define AkMax(x1, x2)
Definition: AkSoundEngineTypes.h:45
AK
Definition of data structures for AkAudioObject.
Definition: AkWwiseSDKVersion.cs:31
AK_SpeakerVolumes_Vector_MulScalar
AkForceInline void AK_SpeakerVolumes_Vector_MulScalar(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannels)
Multiply volume vector with a scalar.
Definition: AkSpeakerVolumes.h:88
AK_SpeakerVolumes_Vector_Zero
AkForceInline void AK_SpeakerVolumes_Vector_Zero(AkSpeakerVolumesVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
Clear volumes.
Definition: AkSpeakerVolumes.h:60
AK_SpeakerVolumes_Matrix_GetRequiredSize
AkForceInline AkUInt32 AK_SpeakerVolumes_Matrix_GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Compute size (in bytes) required for given channel configurations.
Definition: AkSpeakerVolumes.h:124
AkSpeakerVolumesMatrixPtr
AkReal32 * AkSpeakerVolumesMatrixPtr
Definition: AkTypedefs.h:83
AK_SpeakerVolumes_Matrix_MAdd
AkForceInline void AK_SpeakerVolumes_Matrix_MAdd(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
Pointwise Multiply-Add of all elements of two volume matrices.
Definition: AkSpeakerVolumes.h:192
AK::SpeakerVolumes::Matrix::GetRequiredSize
AkForceInline AkUInt32 GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:271
AK_SpeakerVolumes_Matrix_GetChannel
AkForceInline AkSpeakerVolumesVectorPtr AK_SpeakerVolumes_Matrix_GetChannel(AkSpeakerVolumesMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
Get pointer to volume distribution for input channel in_uIdxChannelIn.
Definition: AkSpeakerVolumes.h:136
AK::SpeakerVolumes::Matrix::GetNumElements
AkForceInline AkUInt32 GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:275
AkReal32
float AkReal32
32-bit floating point
Definition: AkNumeralTypes.h:43
AK_SpeakerVolumes_Matrix_Copy
AkForceInline void AK_SpeakerVolumes_Matrix_Copy(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Copy matrix.
Definition: AkSpeakerVolumes.h:146
AK::SpeakerVolumes::Matrix::Zero
AkForceInline void Zero(AkSpeakerVolumesMatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:295
AkMin
#define AkMin(x1, x2)
Definition: AkSoundEngineTypes.h:46
AK_SpeakerVolumes_Vector_Copy
AkForceInline void AK_SpeakerVolumes_Vector_Copy(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Copy volumes.
Definition: AkSpeakerVolumes.h:44
AK_SpeakerVolumes_Vector_Min
AkForceInline void AK_SpeakerVolumes_Vector_Min(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Get min for all elements of two volume vectors, independently.
Definition: AkSpeakerVolumes.h:115
AK::SpeakerVolumes::Matrix::Max
AkForceInline void Max(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:315
AK_SpeakerVolumes_Matrix_AbsMax
AkForceInline void AK_SpeakerVolumes_Matrix_AbsMax(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Get absolute max for all elements of two volume matrices, independently.
Definition: AkSpeakerVolumes.h:202
AK_SpeakerVolumes_Vector_CopyAndApplyGain
AkForceInline void AK_SpeakerVolumes_Vector_CopyAndApplyGain(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain)
Copy volumes with gain.
Definition: AkSpeakerVolumes.h:51
AK::SpeakerVolumes::Matrix::GetChannel
AkForceInline VectorPtr GetChannel(MatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:279
AK::SpeakerVolumes::Matrix::AbsMax
AkForceInline void AbsMax(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:311
AK::SpeakerVolumes::MatrixPtr
AkSpeakerVolumesVectorPtr MatrixPtr
Definition: AkTypedefs.h:104
AK_SpeakerVolumes_Matrix_GetChannel_Const
AkForceInline AkSpeakerVolumesConstVectorPtr AK_SpeakerVolumes_Matrix_GetChannel_Const(AkSpeakerVolumesConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:140
AK::SpeakerVolumes::Matrix::MAdd
AkForceInline void MAdd(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
Definition: AkSpeakerVolumes.h:307
AK::SpeakerVolumes::Matrix::Add
AkForceInline void Add(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:303
AK_SpeakerVolumes_Matrix_GetNumElements
AkForceInline AkUInt32 AK_SpeakerVolumes_Matrix_GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Compute size (in number of elements) required for given channel configurations.
Definition: AkSpeakerVolumes.h:130
AK_SpeakerVolumes_Matrix_Max
AkForceInline void AK_SpeakerVolumes_Matrix_Max(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Get max for all elements of two volume matrices, independently.
Definition: AkSpeakerVolumes.h:212
AK::SpeakerVolumes::ConstVectorPtr
AkSpeakerVolumesConstVectorPtr ConstVectorPtr
Definition: AkTypedefs.h:105
AK::SpeakerVolumes::Vector::Min
AkForceInline void Min(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:262
AK::SpeakerVolumes::Vector::Max
AkForceInline void Max(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:258
AkSpeakerVolumesVectorPtr
AkReal32 * AkSpeakerVolumesVectorPtr
Constant volume vector. Access each element with the standard bracket [] operator.
Definition: AkTypedefs.h:86
AK_SpeakerVolumes_Vector_Mul
AkForceInline void AK_SpeakerVolumes_Vector_Mul(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Multiply two volume vectors.
Definition: AkSpeakerVolumes.h:97
AK_SpeakerVolumes_Matrix_Mul
AkForceInline void AK_SpeakerVolumes_Matrix_Mul(AkSpeakerVolumesMatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Multiply a matrix with a scalar.
Definition: AkSpeakerVolumes.h:172
AK::SpeakerVolumes::ConstMatrixPtr
AkSpeakerVolumesConstMatrixPtr ConstMatrixPtr
Definition: AkTypedefs.h:106
AK_SpeakerVolumes_Vector_Max
AkForceInline void AK_SpeakerVolumes_Vector_Max(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Get max for all elements of two volume vectors, independently.
Definition: AkSpeakerVolumes.h:106
AK_SpeakerVolumes_Vector_Add
AkForceInline void AK_SpeakerVolumes_Vector_Add(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Accumulate two volume vectors.
Definition: AkSpeakerVolumes.h:67
AK_SpeakerVolumes_Vector_L1Norm
AkForceInline AkReal32 AK_SpeakerVolumes_Vector_L1Norm(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
Compute the sum of all components of a volume vector.
Definition: AkSpeakerVolumes.h:76
AkUInt32
uint32_t AkUInt32
Unsigned 32-bit integer.
Definition: AkNumeralTypes.h:35
AK::SpeakerVolumes::Matrix::Copy
AkForceInline void Copy(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:287
AK::SpeakerVolumes::Vector::L1Norm
AkForceInline AkReal32 L1Norm(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:246
AkSpeakerVolumesConstMatrixPtr
const AkReal32 * AkSpeakerVolumesConstMatrixPtr
Opaque data structure for storing a collection of external sources. Refer to API in AK/SoundEngine/Co...
Definition: AkTypedefs.h:92
AK::SpeakerVolumes::Matrix::Mul
AkForceInline void Mul(AkSpeakerVolumesMatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Definition: AkSpeakerVolumes.h:299
AK::SpeakerVolumes::Vector::Add
AkForceInline void Add(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:242
AK_SpeakerVolumes_Matrix_Add
AkForceInline void AK_SpeakerVolumes_Matrix_Add(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
Add all elements of two volume matrices, independently.
Definition: AkSpeakerVolumes.h:182
AkForceInline
#define AkForceInline
Definition: AkTypes.h:63
AK::SpeakerVolumes::Vector::Copy
AkForceInline void Copy(AkSpeakerVolumesVectorPtr in_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:230
AK::SpeakerVolumes::VectorPtr
AkSpeakerVolumesMatrixPtr VectorPtr
Definition: AkTypedefs.h:103
AkSpeakerVolumesConstVectorPtr
const AkReal32 * AkSpeakerVolumesConstVectorPtr
Constant volume matrix. Access each input channel vector with AK::SpeakerVolumes::Matrix::GetChannel(...
Definition: AkTypedefs.h:89
AK::SpeakerVolumes::Vector::Zero
AkForceInline void Zero(AkSpeakerVolumesVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:238
AK::SpeakerVolumes::Vector::Mul
AkForceInline void Mul(VectorPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannels)
Definition: AkSpeakerVolumes.h:250
AK_SpeakerVolumes_Matrix_CopyAndApplyGain
AkForceInline void AK_SpeakerVolumes_Matrix_CopyAndApplyGain(AkSpeakerVolumesMatrixPtr in_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
Copy matrix with gain.
Definition: AkSpeakerVolumes.h:154

Cette page a-t-elle été utile ?

Besoin d'aide ?

Des questions ? Des problèmes ? Besoin de plus d'informations ? Contactez-nous, nous pouvons vous aider !

Visitez notre page d'Aide

Décrivez-nous de votre projet. Nous sommes là pour vous aider.

Enregistrez votre projet et nous vous aiderons à démarrer sans aucune obligation !

Partir du bon pied avec Wwise