Version
menu_open
link
Wwise SDK 2021.1.14
IAkPlugin.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  Version: v2021.1.14 Build: 6590
25  Copyright (c) 2006-2023 Audiokinetic Inc.
26 *******************************************************************************/
27 
28 /// \file
29 /// Software source plug-in and effect plug-in interfaces.
30 
31 #ifndef _IAK_PLUGIN_H_
32 #define _IAK_PLUGIN_H_
33 
38 #include <AK/Tools/Common/AkLock.h>
46 #include <AK/AkWwiseSDKVersion.h>
47 
48 #include <math.h>
49 
50 #if defined AK_CPU_X86 || defined AK_CPU_X86_64
51 #include <xmmintrin.h>
52 #endif
53 
54 /// Plug-in information structure.
55 /// \remarks The bIsInPlace field is only relevant for effect plug-ins.
56 /// \sa
57 /// - \ref iakeffect_geteffectinfo
58 struct AkPluginInfo
59 {
60  /// Constructor for default values
63  , uBuildVersion( 0 )
64  , bIsInPlace(true)
65  , bCanChangeRate(false)
66  , bReserved(false)
67  , bCanProcessObjects(false)
68  , bIsDeviceEffect(false)
69  , bCanRunOnObjectConfig(true)
70  , bUsesGainAttribute(false)
71  {}
72 
73  AkPluginType eType; ///< Plug-in type
74  AkUInt32 uBuildVersion; ///< Plug-in build version, must match the AK_WWISESDK_VERSION_COMBINED macro from AkWwiseSDKVersion.h. Prevents usage of plugins compiled for other versions, avoiding crashes or data issues.
75  bool bIsInPlace; ///< Buffer usage (in-place or not). If true, and the plug-in is an insert effect, it should implement IAkInPlaceEffectPlugin, otherwise it should implement IAkOutOfPlaceEffectPlugin. If it is an object processor (see CanProcessObjects, below), it should implement IAkInPlaceObjectPlugin or IAkOutOfPlaceObjectPlugin respectively.
76  bool bCanChangeRate; ///< True for effects whose sample throughput is different between input and output. Effects that can change rate need to be out-of-place (!bIsInPlace), and cannot exist on busses.
77  bool bReserved; ///< Legacy bIsAsynchronous plug-in flag, now unused. Preserved for plug-in backward compatibility. bReserved should be false for all plug-in.
78  bool bCanProcessObjects; ///< Plug-in can process audio objects. They must implement IAkInPlaceObjectPlugin or IAkOutOfPlaceObjectPlugin, depending on if they work in-place or out-of-place. Out-of-place object processors only work on busses.
79  bool bIsDeviceEffect; ///< Plug-in can process final mixes and objects right before sending them to the audio device for output. Plug-ins that process the main mix, passthrough mix and objects directly at the end of the pipeline must implement IAkAudioDeviceEffectPlugin. Audio device effect plug-ins must be in place (bIsInPlace = true) and must be able to process objects (bCanProcessObjects = true).
80  bool bCanRunOnObjectConfig; ///< Plug-in can run on bus with Audio Object configuration. Effect plug-ins are instantiated once per Audio Objects on those busses. While this may be fine for effects such as EQs, it is an user error for effects such as reverbs, or for any effect that is non-linear. Effects that return false will fail to initialize when created on busses with Audio Object Configuration.
81  bool bUsesGainAttribute; ///< Plug-in knows how to process objects separately from the cumulativeGain of the object (or the processing of the object's audio is independent of the overall object gain). bCanProcessObjects must also be true, as this relies on Object Metadata.
82 };
83 
84 //Forward declarations.
85 namespace AK
86 {
87  class PluginRegistration;
88 }
90 
91 struct AkAcousticTexture;
92 
93 namespace AK
94 {
95  class IAkStreamMgr;
96  class IAkGlobalPluginContext;
97 
98  /// Game object information available to plugins.
100  {
101  protected:
102  /// Virtual destructor on interface to avoid warnings.
104 
105  public:
106 
107  /// Get the ID of the game object.
108  virtual AkGameObjectID GetGameObjectID() const = 0;
109 
110  /// Retrieve the number of emitter-listener pairs (rays) of the game object.
111  /// A game object may have more than one position, and be listened to more than one listener.
112  /// The returned value is the product of these two numbers. Use the returned value as a higher
113  /// bound for the index of GetEmitterListenerPair().
114  /// Note that rays whose listener is irrelevant to the current context are ignored. For example,
115  /// if the calling plug-in exists on a bus, only listeners that are routed to the end point's
116  /// device are considered.
117  /// \sa
118  /// - AK::SoundEngine::SetPosition()
119  /// - AK::SoundEngine::SetMultiplePositions()
120  /// - AK::SoundEngine::SetListeners()
121  /// - AK::IAkGameObjectPluginInfo::GetEmitterListenerPair()
123 
124  /// Retrieve the emitter-listener pair (ray) of the game object at index in_uIndex.
125  /// Call GetNumEmitterListenerPairs() prior to this function to get the total number of
126  /// emitter-listener pairs of the game object.
127  /// The emitter-listener pair is expressed as the game object's position relative to the
128  /// listener, in spherical coordinates.
129  /// \note
130  /// - The distance takes game object and listener scaling factors into account.
131  /// - Returned distance and angles are those of the game object, and do not necessarily correspond
132  /// to any sound's positioning data.
133  /// \return AK_Fail if the index is invalid, AK_Success otherwise.
134  /// \sa
135  /// - AK::SoundEngine::SetScalingFactor()
136  /// - AK::IAkGameObjectPluginInfo::GetNumEmitterListenerPairs()
138  AkUInt32 in_uIndex, ///< Index of the pair, [0, GetNumEmitterListenerPairs()[
139  AkEmitterListenerPair & out_emitterListenerPair ///< Returned relative source position in spherical coordinates.
140  ) const = 0;
141 
142  /// Get the number of positions of the game object. Use this value to determine the indices to be
143  /// passed to GetGameObjectPosition().
144  /// \sa
145  /// - AK::SoundEngine::SetPosition()
146  /// - AK::SoundEngine::SetMultiplePositions()
147  /// - AK::IAkGameObjectPluginInfo::GetGameObjectPosition();
148  virtual AkUInt32 GetNumGameObjectPositions() const = 0;
149 
150  /// Get the raw position of the game object at index in_uIndex.
151  /// Use GetNumGameObjectPositions() prior to this function to get the total number of positions
152  /// of that game object.
153  /// \return AK_Fail if the index is out of bounds, AK_Success otherwise.
154  /// \sa
155  /// - AK::SoundEngine::SetPosition()
156  /// - AK::SoundEngine::SetMultiplePositions()
157  /// - AK::IAkGameObjectPluginInfo::GetNumGameObjectPositions()
159  AkUInt32 in_uIndex, ///< Index of the position, [0, GetNumGameObjectPositions()[
160  AkSoundPosition & out_position ///< Returned raw position info.
161  ) const = 0;
162 
163  /// Get the multi-position type assigned to the game object.
164  /// \return MultiPositionType_MultiSources when the effect is instantiated on a bus.
165  /// \sa
166  /// - AK::SoundEngine::SetPosition()
167  /// - AK::SoundEngine::SetMultiplePositions()
169 
170  /// Get the distance scaling factor of the associated game object.
171  /// \sa
172  /// - AK::SoundEngine::SetScalingFactor()
173  virtual AkReal32 GetGameObjectScaling() const = 0;
174 
175  /// Get the game object IDs of listener game objects that are listening to the emitter game object.
176  /// Note that only listeners relevant to the current context are considered. For example,
177  /// if the calling plug-in exists on a bus, only listeners that are routed to the end point's
178  /// device are added to the returned array.
179  /// \return True if the call succeeded, false if all the listeners could not fit into the array,
180  /// \sa
181  /// - AK::SoundEngine::SetListeners()
182  virtual bool GetListeners(
183  AkGameObjectID* out_aListenerIDs, ///< Array of listener IDs to fill, or NULL to query the size needed.
184  AkUInt32& io_uSize ///< In: max size of the array, out: number of valid elements returned in out_aListenerIDs.
185  ) const = 0;
186 
187  /// Get information about a listener. Use GetListeners() prior to this function
188  /// in order to know which listeners are listening to the associated game object.
189  /// \return AK_Fail if the listener ID is invalid. AK_Success otherwise.
190  /// \sa
191  /// - AK::SoundEngine::SetListeners()
192  /// - AK::IAkGameObjectPluginInfo::GetListeners()
194  AkGameObjectID in_uListener, ///< Bit field identifying the listener for which you desire information.
195  AkListener & out_listener ///< Returned listener info.
196  ) const = 0;
197  };
198 
199  /// Voice-specific information available to plug-ins.
201  {
202  protected:
203  /// Virtual destructor on interface to avoid warnings.
205 
206  public:
207 
208  /// Retrieve the Playing ID of the event corresponding to this voice (if applicable).
209  virtual AkPlayingID GetPlayingID() const = 0;
210 
211  /// Get priority value associated to this voice. When priority voice is modified by distance, the minimum distance among emitter-listener pairs is used.
212  /// \return The priority between AK_MIN_PRIORITY and AK_MAX_PRIORITY inclusively.
213  virtual AkPriority GetPriority() const = 0;
214 
215  /// Get priority value associated to this voice, for a specified distance, which may differ from the minimum distance that is used by default.
216  /// \return The priority between AK_MIN_PRIORITY and AK_MAX_PRIORITY inclusively.
218  AkReal32 in_fDistance ///< Distance.
219  ) const = 0;
220  };
221 
222  /// Interface to retrieve contextual information available to all types of plugins.
224  {
225  protected:
226  /// Virtual destructor on interface to avoid warnings.
228 
229  public:
230 
231  /// \return The global sound engine context.
232  /// \sa IAkGlobalPluginContext
233  virtual IAkGlobalPluginContext* GlobalContext() const = 0;
234 
235  /// Obtain the interface to access the game object on which the plugin is instantiated.
236  /// \return The interface to GameObject info, nullptr if undefined.
238 
239  /// Identify the output device into which the data processed by this plugin will end up.
240  /// Applicable to plug-ins instantiated as bus effects and to sink plugins.
241  /// Plug-ins instantiated in the Actor-Mixer hierarchy (i.e. on voices) return AK_NotCompatible.
242  /// \sa integrating_secondary_outputs
243  /// \return The device type and unique identifier. AK_Success if successful, AK_NotCompatible otherwise.
245  AkUInt32 & out_uOutputID, ///< Device identifier, when multiple devices of the same type are possible.
246  AkPluginID & out_uDevicePlugin ///< Device plugin ID.
247  ) const = 0;
248 
249  /// Return the pointer and size of the plug-in media corresponding to the specified index.
250  /// The pointer returned will be NULL if the plug-in media is either not loaded or inexistant.
251  /// When this function is called and returns a valid data pointer, the data can only be used by this
252  /// instance of the plugin and is guaranteed to be valid only during the plug-in lifespan.
253  virtual void GetPluginMedia(
254  AkUInt32 in_dataIndex, ///< Index of the plug-in media to be returned.
255  AkUInt8* &out_rpData, ///< Pointer to the data
256  AkUInt32 &out_rDataSize ///< size of the data returned in bytes.
257  ) = 0;
258 
259  /// Return the pointer and size of the game data corresponding to the specified index, sent by the game using AK::SoundEngine::SendPluginCustomGameData().
260  /// The pointer returned will be NULL if the game data is inexistent.
261  /// When this function is called and returns a valid data pointer, the data can only be used by this
262  /// instance of the plugin and is guaranteed to be valid only during the frame.
263  virtual void GetPluginCustomGameData(
264  void* &out_rpData, ///< Pointer to the data
265  AkUInt32 &out_rDataSize ///< size of the data returned in bytes.
266  ) = 0;
267 
268  /// Post a custom blob of data to the UI counterpart of this effect plug-in.
269  /// Data is sent asynchronously through the profiling system.
270  /// Notes:
271  /// - It is only possible to post data when the instance of the plug-in is on a bus or audio device
272  /// because there is a one-to-one relationship with its effect settings view.
273  /// You may call CanPostMonitorData() to determine if your plug-in can send data to the UI.
274  /// - Data is copied into the communication buffer within this method,
275  /// so you may discard it afterwards.
276  /// - You need to handle byte swapping on one side or the other when sending
277  /// data from a big-endian platform.
278  /// - Sending data to the UI is only possible in Debug and Profile. Thus, you should
279  /// enclose your calls to package and send that data within !AK_OPTIMIZED preprocessor flag.
280  /// \return AK_Success if the plug-in exists on a bus, AK_Fail otherwise.
282  void * in_pData, ///< Blob of data.
283  AkUInt32 in_uDataSize ///< Size of data.
284  ) = 0;
285 
286  /// Query the context to know if it is possible to send data to the UI counterpart of this effect plug-in.
287  /// It is only possible to post data when the instance of the plug-in is on a bus or audio device, because there is a
288  /// one-to-one relationship with its effect settings view.
289  /// \return True if the instance of the plug-in is on a bus, and the authoring tool is connected and
290  /// monitoring the game, false otherwise.
291  /// \sa PostMonitorData()
292  virtual bool CanPostMonitorData() = 0;
293 
294  /// Post a monitoring message or error string. This will be displayed in the Wwise capture
295  /// log.
296  /// \return AK_Success if successful, AK_Fail if there was a problem posting the message.
297  /// In optimized mode, this function returns AK_NotCompatible.
298  /// \remark This function is provided as a tracking tool only. It does nothing if it is
299  /// called in the optimized/release configuration and return AK_NotCompatible.
301  const char* in_pszError, ///< Message or error string to be displayed
302  AK::Monitor::ErrorLevel in_eErrorLevel ///< Specifies whether it should be displayed as a message or an error
303  ) = 0;
304 
305  /// Get the cumulative gain of all mixing stages, from the host audio node down to the device end point.
306  /// Returns 1.f when the node is an actor-mixer (voice), because a voice may be routed to several mix chains.
307  /// \return The cumulative downstream gain.
309 
310  /// Return the channel configuration of the parent node that this effect will mix into. GetParentChannelConfig() may be used to set the output configuration of an
311  /// out-of-place effect to avoid additional up/down mixing stages. Please note however that it is possible for out-of-place effects later in the chain to change
312  /// this configuration.
313  /// Returns not out_channelConfig.IsValid() when the node is an actor-mixer (voice), because a voice may be routed to several mix chains.
314  /// \return AK_Success if the channel config of the primary, direct parent bus could be determined, AK_Fail otherwise.
316  AkChannelConfig& out_channelConfig ///< Channel configuration of parent node (downstream bus).
317  ) const = 0;
318 
319  /// Return an interface to query processor specific features.
321 
322  /// Get internal ID of hosting sound structure (actor-mixer of bus).
323  /// In the case of a voice, the ID is internal but corresponds to what you would get from the duration
324  /// callback (see AkDurationCallbackInfo::audioNodeID). In the case of a bus, it can be matched with the bus name converted
325  /// to a unique ID using AK::SoundEngine::GetIDFromString().
326  /// In the case if an audio device (sink), it is AK_INVALID_UNIQUE_ID.
327  /// \return ID of input.
328  /// \sa
329  /// - AkDurationCallbackInfo
330  /// - AK::SoundEngine::PostEvent()
331  /// - AK::SoundEngine::GetIDFromString()
332  virtual AkUniqueID GetAudioNodeID() const = 0;
333  };
334 
335  /// Interface to retrieve contextual information for an effect plug-in.
336  /// \sa
337  /// - \ref iakmonadiceffect_init
339  {
340  protected:
341  /// Virtual destructor on interface to avoid warnings.
343 
344  public:
345 
346  /// Determine whether the effect is to be used in Send Mode or not.
347  /// Effects used in auxiliary busses are always used in Send Mode.
348  /// \return True if the effect is in Send Mode, False otherwise
349  virtual bool IsSendModeEffect() const = 0;
350 
351  /// Obtain the interface to access the voice in which the plugin is inserted.
352  /// \return The interface to voice info. NULL if the plugin is instantiated on a bus.
354 
355  /// Obtain the interface to access services available on busses.
356  /// \return The interface to mixing context if the plugin is instantiated on a bus. NULL if it is instantiated on a voice.
358 
359  /// \name For object processors:
360  /// Output object management.
361  //@{
362 
363  /// Create new objects on the output side. Only out-of-place object processors (plugins implementing AK::IAkOutOfPlaceObjectPlugin) may create output objects.
364  /// If successful, the newly constructed objects will be available in out_ppBuffer/out_ppObjects.
365  /// To obtain all the output objects in a single array after having created objects using this function, use GetOutputObjects, or wait for the next call to AK::IAkOutOfPlaceObjectPlugin::Execute
366  /// where output objects are passed via the in_pObjectBuffersOut/in_pObjectsOut arguments.
367  /// Object processors inform the host that an output object may be disposed of by setting its state to AK_NoMoreData from within AK::IAkOutOfPlaceObjectPlugin::Execute.
368  /// \aknote You should never store the pointers returned by out_ppBuffer/out_ppObjects, as the location of pointed objects may change at each frame, or after subsequent calls to CreateOutputObjects.\endaknote
369  /// \return AK_Success if all objects were created successfully, AK_Fail otherwise.
370  /// The optional arguments out_ppBuffer and out_ppObjects may be used to obtain the output objects newly created.
371  /// \sa
372  /// - GetOutputObjects
373  /// - AK::IAkOutOfPlaceObjectPlugin::Execute
375  AkChannelConfig in_channelConfig, ///< Desired channel configuration for all new objects.
376  AkAudioObjects& io_objects ///< AkAudioObjects::uNumObjects, the number of objects to create.
377  ///< AkAudioObjects::ppObjectBuffers, Returned array of pointers to the object buffers newly created, allocated by the caller. Pass nullptr if they're not needed.
378  ///< AkAudioObjects::ppObjects, Returned array of pointers to the objects newly created, allocated by the caller. Pass nullptr if they're not needed.
379  ) = 0;
380 
381  /// Access the output objects. This function is helpful when CreateOutputObjects is called from within AK::IAkOutOfPlaceObjectPlugin::Execute.
382  /// You need to allocate the array of pointers. You may prealably obtain the number of objects by calling this function with io_numObjects = 0.
383  /// \aknote You should never store the pointers returned by GetOutputObjects, as the location of pointed objects may change at each frame, or after calls to CreateOutputObjects.\endaknote
384  virtual void GetOutputObjects(
385  AkAudioObjects& io_objects ///< AkAudioObjects::uNumObjects, The number of objects. If 0 is passed, io_objects::numObjects returns with the total number of objects.
386  ///< AkAudioObjects::ppObjectBuffers, Returned array of pointers to object buffers, allocated by the caller. The number of objects is the smallest between io_numObjects and the total number of objects.
387  ///< AkAudioObjects::ppObjects, Returned array of pointers to objects, allocated by the caller. The number of objects is the smallest between io_numObjects and the total number of objects.
388  ) = 0;
389 
390  //@}
391  };
392 
393  /// Interface to retrieve contextual information for a source plug-in.
394  /// \sa
395  /// - \ref iaksourceeffect_init
397  {
398  protected:
399  /// Virtual destructor on interface to avoid warnings.
401 
402  public:
403 
404  /// Retrieve the number of loops the source should produce.
405  /// \return The number of loop iterations the source should produce (0 if infinite looping)
406  virtual AkUInt16 GetNumLoops() const = 0;
407 
408  /// Obtain the interface to access the voice in which the plugin is inserted.
409  /// \return The interface to voice info.
411 
412  /// Obtain the MIDI event info associated to the source.
413  /// \return The MIDI event info.
414  ///
415  virtual AkMIDIEvent GetMidiEvent() const = 0;
416 
417  /// Retrieve Cookie information for a Source Plugin
418  /// \return the void pointer of the Cookie passed to the PostEvent
419  virtual void* GetCookie() const = 0;
420 
421  };
422 
423  /// Interface to retrieve contextual information for a mixer.
425  {
426  protected:
427  /// Virtual destructor on interface to avoid warnings.
429 
430  public:
431 
432  /// DEPRECATED.
433  /// Get the type of the bus on which the mixer plugin is instantiated.
434  /// AkBusHierachyFlags is a bit field, indicating whether the bus is the master (top-level) bus or not,
435  /// and whether it is in the primary or secondary mixing graph.
436  /// \return The bus type.
437  virtual AkUInt32 GetBusType() = 0;
438 
439  /// Get speaker angles of the specified device.
440  /// The speaker angles are expressed as an array of loudspeaker pairs, in degrees, relative to azimuth ]0,180].
441  /// Supported loudspeaker setups are always symmetric; the center speaker is always in the middle and thus not specified by angles.
442  /// Angles must be set in ascending order.
443  /// You may call this function with io_pfSpeakerAngles set to NULL to get the expected number of angle values in io_uNumAngles,
444  /// in order to allocate your array correctly. You may also obtain this number by calling
445  /// AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ).
446  /// If io_pfSpeakerAngles is not NULL, the array is filled with up to io_uNumAngles.
447  /// Typical usage:
448  /// - AkUInt32 uNumAngles;
449  /// - GetSpeakerAngles( NULL, uNumAngles );
450  /// - AkReal32 * pfSpeakerAngles = AkAlloca( uNumAngles * sizeof(AkReal32) );
451  /// - GetSpeakerAngles( pfSpeakerAngles, uNumAngles );
452  /// \warning Call this function only after the sound engine has been properly initialized.
453  /// \return AK_Success if the end point device is properly initialized, AK_Fail otherwise.
454  /// \sa AK::SoundEngine::GetSpeakerAngles()
456  AkReal32 * io_pfSpeakerAngles, ///< Returned array of loudspeaker pair angles, in degrees relative to azimuth [0,180]. Pass NULL to get the required size of the array.
457  AkUInt32 & io_uNumAngles, ///< Returned number of angles in io_pfSpeakerAngles, which is the minimum between the value that you pass in, and the number of angles corresponding to the output configuration, or just the latter if io_pfSpeakerAngles is NULL.
458  AkReal32 & out_fHeightAngle ///< Elevation of the height layer, in degrees relative to the plane.
459  ) = 0;
460 
461  /// \name Services.
462  //@{
463 
464  /// Compute a direct speaker assignment volume matrix with proper downmixing rules between two channel configurations.
465  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
466  /// \aknote ComputePositioning is more general than this one, as it can also compute speaker gains for non-3D spatialization, and should be favored.\endaknote
467  /// \return AK_Success if successful, AK_Fail otherwise.
468  /// \sa IAkGlobalPluginContext
470  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
471  AkChannelConfig in_outputConfig, ///< Channel configuration of the mixer output.
472  AkReal32 in_fCenterPerc, ///< Center percentage. Only applies to mono inputs with standard output configurations that have a center channel.
473  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
474  ) = 0;
475 
476  /// Compute a volume matrix given the position of the panner (Wwise 2D panner).
477  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
478  /// \aknote ComputePositioning is more general than this one, as it can also compute speaker gains for 3D spatialization, and should be favored.\endaknote
479  /// \return AK_Success if successful, AK_Fail otherwise.
480  /// \sa IAkGlobalPluginContext
482  AkSpeakerPanningType in_ePannerType, ///< Panner type
483  const AkVector & in_position, ///< x,y,z panner position [-1,1]. Note that z has no effect at the moment.
484  AkReal32 in_fCenterPct, ///< Center percentage.
485  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
486  AkChannelConfig in_outputConfig, ///< Channel configuration of the mixer output.
487  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
488  ) = 0;
489 
490  /// Compute panning gains on the plane given an incidence angle and channel configuration.
491  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
492  /// \aknote ComputePositioning is more general than this one, as it can also compute speaker gains for non-3D spatialization, and should be favored.\endaknote
493  /// \return AK_Success if successful, AK_Fail otherwise.
494  /// \sa IAkGlobalPluginContext
496  AkReal32 in_fAngle, ///< Incident angle, in radians [-pi,pi], where 0 is the azimuth (positive values are clockwise)
497  AkChannelConfig in_outputConfig, ///< Desired output configuration.
498  AkReal32 in_fCenterPerc, ///< Center percentage. Only applies to mono inputs to outputs that have no center.
499  AK::SpeakerVolumes::VectorPtr out_vVolumes ///< Returned volumes (see AK::SpeakerVolumes::Vector services). Must be allocated prior to calling this function with the size returned by AK::SpeakerVolumes::Vector::GetRequiredSize() for the desired configuration.
500  ) = 0;
501 
502  /// Initialize spherical VBAP
503  /// \return AK_Success if successful, AK_Fail otherwise.
505  AK::IAkPluginMemAlloc* in_pAllocator, ///< Memory allocator
506  const AkSphericalCoord* in_SphericalPositions, ///< Array of points in spherical coordinate, representign the virtual position of each channels.
507  const AkUInt32 in_NbPoints, ///< Number of points in the position array
508  void *& out_pPannerData ///< Contains data relevant to the 3D panner that shoud be re-used accross plugin instances.
509  ) = 0;
510 
511  /// Compute panning gains on the plane given an incidence angle and channel configuration.
512  /// \aknote ComputePositioning is more general than this one, as it handles spread and focus, and can also compute speaker gains for non-3D spatialization, and should be favored.\endaknote
513  /// \return AK_Success if successful, AK_Fail otherwise.
515  void* in_pPannerData, ///< Contains data relevant to the 3D panner that shoud be re-used accross plugin instances.
516  AkReal32 in_fAzimuth, ///< Incident angle, in radians [-pi,pi], where 0 is the azimuth (positive values are clockwise)
517  AkReal32 in_fElevation, ///< Incident angle, in radians [0,pi], where 0 is the elevation (positive values are clockwise)
518  AkUInt32 in_uNumChannels, ///< Number of output channels.
519  AK::SpeakerVolumes::VectorPtr out_vVolumes ///< Returned volumes (see AK::SpeakerVolumes::Vector services). Must be allocated prior to calling this function with the size returned by AK::SpeakerVolumes::Vector::GetRequiredSize() for the desired configuration.
520  ) = 0;
521 
522  /// Clear panner data obtained from InitSphericalVBAP().
523  /// \return AK_Success if successful, AK_Fail otherwise.
525  AK::IAkPluginMemAlloc* in_pAllocator, ///< Memory allocator
526  void* in_pPannerData ///< Contains data relevant to the 3D panner that shoud be re-used accross plugin instances.
527  ) = 0;
528 
529  /// Compute standard 3D positioning.
530  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
531  /// \aknote The cartesian counterpart of Compute3DPositioning, that uses emitter and listener transforms, should be used instead of this function.
532  /// It is more complete and more efficient. \endaknote
533  /// \aknote ComputePositioning is more general than this one, as it can also compute speaker gains for non-3D spatialization, and should be favored.\endaknote
534  /// \return AK_Success if successful, AK_Fail otherwise.
535  /// \sa IAkGlobalPluginContext
537  AkReal32 in_fAngle, ///< Incident angle, in radians [-pi,pi], where 0 is the azimuth (positive values are clockwise).
538  AkReal32 in_fElevation, ///< Incident elevation angle, in radians [-pi/2,pi/2], where 0 is the horizon (positive values are above the horizon).
539  AkReal32 in_fSpread, ///< Spread ([0,1]).
540  AkReal32 in_fFocus, ///< Focus ([0,1]).
541  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
542  AkChannelMask in_uInputChanSel, ///< Mask of input channels selected for panning (excluded input channels don't contribute to the output).
543  AkChannelConfig in_outputConfig, ///< Desired output configuration.
544  AkReal32 in_fCenterPerc, ///< Center percentage. Only applies to mono inputs to outputs that have a center.
545  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
546  ) = 0;
547 
548  /// Compute standard 3D positioning.
549  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
550  /// \aknote This function is more complete and more efficient than the Compute3DPositioning service that uses spherical coordinates, and should be favored.\endaknote
551  /// \aknote ComputePositioning is more general than this one, as it can also compute speaker gains for non-3D spatialization, and should be favored.\endaknote
552  /// \return AK_Success if successful, AK_Fail otherwise.
553  /// \sa IAkGlobalPluginContext
555  const AkTransform & in_emitter, ///< Emitter transform.
556  const AkTransform & in_listener, ///< Listener transform.
557  AkReal32 in_fCenterPerc, ///< Center percentage. Only applies to mono inputs to outputs that have a center.
558  AkReal32 in_fSpread, ///< Spread ([0,1]).
559  AkReal32 in_fFocus, ///< Focus ([0,1]).
560  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
561  AkChannelMask in_uInputChanSel, ///< Mask of input channels selected for panning (excluded input channels don't contribute to the output).
562  AkChannelConfig in_outputConfig, ///< Desired output configuration.
563  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
564  ) = 0;
565 
566  /// Compute the speaker volume matrix of built-in positioning in Wwise from given positioning data and input and output channel configurations.
567  /// You may use the returned volume matrix with IAkGlobalPluginContext::MixNinNChannels.
568  /// Any known (non-anonymous) combination of configurations will work. For example, ambisonics will be decoded or encoded if needed.
569  /// \aknote The function will fail if the input or output configuration is object-based, as the speaker volume matrix would be undefined.\endaknote
570  /// All panning or spatialization types are honored.
571  /// 3D Spatialization is performed relative to the default listener position (0,0,0) and orientation, where the front vector is (0,0,1) and the top vector is (0,1,0), left handed.
572  /// \return AK_Success if succeeded, AK_InvalidParameter if the input or output configuration is object-based, or AK_Fail if the channel configurations are unknown or unhandled.
573  /// \sa IAkGlobalPluginContext
575  const AkPositioningData& in_posData, ///< Positioning data. The field "threeD" is ignored if in_posData.behavioral.spatMode is AK_SpatializationMode_None.
576  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
577  AkChannelConfig in_outputConfig, ///< Channel configuration of the output.
578  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
579  ) = 0;
580 
581 
582  //@}
583 
584  /// \name Metering.
585  //@{
586 
587  /// Set flags for controlling computation of metering values on the mix buffer.
588  /// Pass AK_NoMetering to disable metering.
589  /// \sa
590  /// - AK::IAkMetering
591  virtual void EnableMetering( AkMeteringFlags in_eFlags ) = 0;
592 
593  //@}
594  };
595 
596  /// Parameter node interface, managing access to an enclosed parameter structure.
597  /// \aknote The implementer of this interface should also expose a static creation function
598  /// that will return a new parameter node instance when required (see \ref se_plugins_overview). \endaknote
599  /// \sa
600  /// - \ref shared_parameter_interface
602  {
603  protected:
604  /// Virtual destructor on interface to avoid warnings.
605  virtual ~IAkPluginParam(){}
606 
607  public:
608  /// Create a duplicate of the parameter node instance in its current state.
609  /// \aknote The allocation of the new parameter node should be done through the AK_PLUGIN_NEW() macro. \endaknote
610  /// \return Pointer to a duplicated plug-in parameter node interface
611  /// \sa
612  /// - \ref iakeffectparam_clone
614  IAkPluginMemAlloc * in_pAllocator ///< Interface to memory allocator to be used
615  ) = 0;
616 
617  /// Initialize the plug-in parameter node interface.
618  /// Initializes the internal parameter structure to default values or with the provided parameter
619  /// block if it is valid. \endaknote
620  /// \aknote If the provided parameter block is valid, use SetParamsBlock() to set all parameters at once. \endaknote
621  /// \return Possible return values are: AK_Success, AK_Fail, AK_InvalidParameter
622  /// \sa
623  /// - \ref iakeffectparam_init
624  virtual AKRESULT Init(
625  IAkPluginMemAlloc * in_pAllocator, ///< Interface to the memory allocator to be used
626  const void * in_pParamsBlock, ///< Pointer to a parameter structure block
627  AkUInt32 in_uBlockSize ///< Size of the parameter structure block
628  ) = 0;
629 
630  /// Called by the sound engine when a parameter node is terminated.
631  /// \aknote The self-destruction of the parameter node must be done using the AK_PLUGIN_DELETE() macro. \endaknote
632  /// \return AK_Success if successful, AK_Fail otherwise
633  /// \sa
634  /// - \ref iakeffectparam_term
635  virtual AKRESULT Term(
636  IAkPluginMemAlloc * in_pAllocator ///< Interface to memory allocator to be used
637  ) = 0;
638 
639  /// Set all plug-in parameters at once using a parameter block.
640  /// \return AK_Success if successful, AK_InvalidParameter otherwise
641  /// \sa
642  /// - \ref iakeffectparam_setparamsblock
644  const void *in_pParamsBlock, ///< Pointer to a parameter structure block
645  AkUInt32 in_uBlockSize ///< Size of the parameter structure block
646  ) = 0;
647 
648  /// Update a single parameter at a time and perform the necessary actions on the parameter changes.
649  /// \aknote The parameter ID corresponds to the AudioEnginePropertyID in the plug-in XML description file. \endaknote
650  /// \return AK_Success if successful, AK_InvalidParameter otherwise
651  /// \sa
652  /// - \ref iakeffectparam_setparam
654  AkPluginParamID in_paramID, ///< ID number of the parameter to set
655  const void * in_pValue, ///< Pointer to the value of the parameter to set
656  AkUInt32 in_uParamSize ///< Size of the value of the parameter to set
657  ) = 0;
658 
659  /// Use this constant with AK::Wwise::IPluginPropertySet::NotifyInternalDataChanged,
660  /// AK::Wwise::IAudioPlugin::GetPluginData and IAkPluginParam::SetParam. This tells
661  /// that the whole plugin data needs to be saved/transferred.
662  ///\sa
663  /// - AK::Wwise::IPluginPropertySet::NotifyInternalDataChanged
664  /// - AK::Wwise::IAudioPlugin::GetPluginData
665  /// - AK::IAkPluginParam::SetParam
666  static const AkPluginParamID ALL_PLUGIN_DATA_ID = 0x7FFF;
667  };
668 
669  /// Wwise sound engine plug-in interface. Shared functionality across different plug-in types.
670  /// \aknote The implementer of this interface should also expose a static creation function
671  /// that will return a new plug-in instance when required (see \ref soundengine_plugins). \endaknote
672  class IAkPlugin
673  {
674  protected:
675  /// Virtual destructor on interface to avoid warnings.
676  virtual ~IAkPlugin(){}
677 
678  public:
679  /// Release the resources upon termination of the plug-in.
680  /// \return AK_Success if successful, AK_Fail otherwise
681  /// \aknote The self-destruction of the plug-in must be done using AK_PLUGIN_DELETE() macro. \endaknote
682  /// \sa
683  /// - \ref iakeffect_term
684  virtual AKRESULT Term(
685  IAkPluginMemAlloc * in_pAllocator ///< Interface to memory allocator to be used by the plug-in
686  ) = 0;
687 
688  /// The reset action should perform any actions required to reinitialize the state of the plug-in
689  /// to its original state (e.g. after Init() or on effect bypass).
690  /// \return AK_Success if successful, AK_Fail otherwise.
691  /// \sa
692  /// - \ref iakeffect_reset
693  virtual AKRESULT Reset() = 0;
694 
695  /// Plug-in information query mechanism used when the sound engine requires information
696  /// about the plug-in to determine its behavior.
697  /// \warning This function can be called before Init. Implementation of this function should not rely on internal state initialized in Init.
698  /// \return AK_Success if successful.
699  /// \sa
700  /// - \ref iakeffect_geteffectinfo
702  AkPluginInfo & out_rPluginInfo ///< Reference to the plug-in information structure to be retrieved
703  ) = 0;
704 
705  /// Some plug-ins are accessing Media from the Wwise sound bank system.
706  /// If the IAkPlugin object is not using media, this function will not be used and should simply return false.
707  /// If the IAkPlugin object is using media, the RelocateMedia feature can be optionally implemented.
708  /// To implement correctly the feature, the plugin must be able to "Hot swap" from a memory location to another one in a single blocking call (AK::IAkPlugin::RelocateMedia)
709  ///
710  /// \sa
711  /// - AK::IAkPlugin::RelocateMedia
712  virtual bool SupportMediaRelocation() const
713  {
714  return false;
715  }
716 
717  /// Some plug-ins are accessing Media from the Wwise sound bank system.
718  /// If the IAkPlugin object is not using media, this function will not be used.
719  /// If the IAkPlugin object is using media, the RelocateMedia feature can be optionally implemented.
720  /// When this function is being called, the IAkPlugin object must make the required changes to remove all
721  /// referenced from the old memory pointer (previously obtained by GetPluginMedia() (and offsets to) to not access anymore the content of the old memory data and start using the newly provided pointer instead.
722  /// The change must be done within the function RelocateMedia().
723  /// After this call, the memory space in in_pOldInMemoryData will be invalidated and cannot be used safely anymore.
724  ///
725  /// This function will not be called if SupportMediaRelocation returned false.
726  ///
727  /// \sa
728  /// - AK::IAkPlugin::SupportMediaRelocation
730  AkUInt8* /*in_pNewMedia*/,
731  AkUInt8* /*in_pOldMedia*/
732  )
733  {
734  return AK_NotImplemented;
735  }
736 
737  };
738 
739  /// Software effect plug-in interface (see \ref soundengine_plugins_effects).
740  class IAkEffectPlugin : public IAkPlugin
741  {
742  protected:
743  /// Virtual destructor on interface to avoid warnings.
744  virtual ~IAkEffectPlugin(){}
745 
746  public:
747  /// Software effect plug-in initialization. Prepares the effect for data processing, allocates memory and sets up the initial conditions.
748  /// \aknote Memory allocation should be done through appropriate macros (see \ref fx_memory_alloc). \endaknote
749  /// \sa
750  /// - \ref iakmonadiceffect_init
751  virtual AKRESULT Init(
752  IAkPluginMemAlloc * in_pAllocator, ///< Interface to memory allocator to be used by the effect
753  IAkEffectPluginContext * in_pEffectPluginContext, ///< Interface to effect plug-in's context
754  IAkPluginParam * in_pParams, ///< Interface to plug-in parameters
755  AkAudioFormat & io_rFormat ///< Audio data format of the input/output signal. Only an out-of-place plugin is allowed to change the channel configuration. Object processors always receive a channel configuration with type "object". They may however change it to any other kind, in which case the host bus will automatically create an output object with the desired channel configuration.
756  ) = 0;
757  };
758 
759  /// Software effect plug-in interface for in-place processing (see \ref soundengine_plugins_effects).
761  {
762  public:
763  /// Software effect plug-in DSP execution for in-place processing.
764  /// \aknote The effect should process all the input data (uValidFrames) as long as AK_DataReady is passed in the eState field.
765  /// When the input is finished (AK_NoMoreData), the effect can output more sample than uValidFrames up to MaxFrames() if desired.
766  /// All sample frames beyond uValidFrames are not initialized and it is the responsibility of the effect to do so when outputting an effect tail.
767  /// The effect must notify the pipeline by updating uValidFrames if more frames are produced during the effect tail.
768  /// \aknote The effect will stop being called by the pipeline when AK_NoMoreData is returned in the the eState field of the AkAudioBuffer structure.
769  /// See \ref iakmonadiceffect_execute_general.
770  virtual void Execute(
771  AkAudioBuffer * io_pBuffer ///< In/Out audio buffer data structure (in-place processing)
772  ) = 0;
773 
774  /// Skips execution of some frames, when the voice is virtual playing from elapsed time.
775  /// This can be used to simulate processing that would have taken place (e.g. update internal state).
776  /// Return AK_DataReady or AK_NoMoreData, depending if there would be audio output or not at that point.
778  AkUInt32 in_uFrames ///< Number of frames the audio processing should advance.
779  ) = 0;
780  };
781 
782 
783  /// Software effect plug-in interface for out-of-place processing (see \ref soundengine_plugins_effects).
785  {
786  public:
787  /// Software effect plug-in for out-of-place processing.
788  /// \aknote An input buffer is provided and will be passed back to Execute() (with an advancing offset based on uValidFrames consumption by the plug-in).
789  /// The output buffer should be filled entirely by the effect (at which point it can report AK_DataReady) except on last execution where AK_NoMoreData should be used.
790  /// AK_DataNeeded should be used when more input data is necessary to continue processing.
791  /// \aknote Only the output buffer eState field is looked at by the pipeline to determine the effect state.
792  /// See \ref iakmonadiceffect_execute_outofplace.
793  virtual void Execute(
794  AkAudioBuffer * in_pBuffer, ///< Input audio buffer data structure
795  AkUInt32 in_uInOffset, ///< Offset position into input buffer data
796  AkAudioBuffer * out_pBuffer ///< Output audio buffer data structure
797  ) = 0;
798 
799  /// Skips execution of some frames, when the voice is virtual playing from elapsed time.
800  /// This can be used to simulate processing that would have taken place (e.g. update internal state).
801  /// Return AK_DataReady or AK_NoMoreData, depending if there would be audio output or not at that point.
803  AkUInt32 &io_uFrames ///< Number of frames the audio processing should advance. The output value should be the number of frames that would be consumed to output the number of frames this parameter has at the input of the function.
804  ) = 0;
805  };
806 
807  /// In-place Object Processor plug-in interface. Implement this interface when your plugin returns both AkPluginInfo::bCanProcessObjects
808  /// and AkPluginInfo::bIsInPlace set to true.
809  /// In-place object processors just modify objects' audio or metadata, but do not destroy objects create additional output objects.
810  /// An object processor may be initialized with an Object configuration, or any channel configuration, depending on the configuration of its input.
811  /// It is not allowed to change the channel configuration in Init.
813  {
814  public:
815 
816  /// In-place object processor plug-in DSP execution.
817  /// \aknote The effect should process all the input data (uValidFrames) of each input object in in_pObjectsIn as long as AK_DataReady is passed in their corresponding eState field.
818  /// When an input object is finished (eState is AK_NoMoreData), the effect can output more samples than uValidFrames, up to MaxFrames() if desired.
819  /// The effect must notify the pipeline by updating uValidFrames of a given object if more frames are produced, and by setting its eState to AK_DataReady as long as more samples will be produced.\endaknote.
820  /// \sa AK::IAkEffectPlugin::Init.
821  virtual void Execute(
822  const AkAudioObjects& io_objects ///< Input/Output objects and object buffers.
823  ) = 0;
824  };
825 
826  /// Out-of-place Object Processor plug-in interface. Implement this interface when your plugin returns AkPluginInfo::bCanProcessObjects set to true
827  /// and AkPluginInfo::bIsInPlace set to false.
828  /// With out-of-place object processors, the set of output objects is different than that of the input objects. Out-of-place object processors typically create
829  /// their own output objects using IAkEffectPluginContext::CreateObject. Alternatively, an output object is created by the host bus if the channel configuration
830  /// returned from Init is not of type AK_ChannelConfigType_Objects.
831  /// Only out-of-place object processors may create output objects or change the output channel configuration.
833  {
834  public:
835 
836  /// Out-of-place object processor plug-in DSP execution.
837  /// \aknote When running out-of-place, the effect must only update uValidFrames and eState fields of output objects.
838  /// When the object processor sets an output object's eState field to AK_NoMoreData, the host will garbage collect them afterwards. \endaknote
839  /// \akwarning If an out-of-place object processor calls AK::IAkEffectPluginContext::CreateOutputObjects from within Execute, it must not access the output objects passed in out_objects, as the pointed objects may have moved elsewhere in memory.
840  /// In that case it must use AK::IAkEffectPluginContext::GetOutputObjects. Arguments in_pObjectBuffersOut and in_pObjectsOut can only be safely used if the plugin creates objects during Init, either via
841  /// AK::IAkEffectPluginContext::CreateOutputObjects, or by setting the channelConfig field of io_rFormat to a normal channel configuration (i.e. whose eConfigType is not AK_ChannelConfigType_Objects). \endakwarning
842  /// \sa AK::IAkEffectPlugin::Init.
843  virtual void Execute(
844  const AkAudioObjects& in_objects, ///< Input objects and object audio buffers.
845  const AkAudioObjects& out_objects ///< Output objects and object audio buffers.
846  ) = 0;
847  };
848 
850  {
851  public:
852  /// Compute the speaker volume matrix of built-in positioning in Wwise from given positioning data and input and output channel configurations.
853  /// Any known (non-anonymous) combination of configurations will work. For example, ambisonics will be decoded or encoded if needed.
854  /// \aknote The function will fail if the input or output configuration is object-based, as the speaker volume matrix would be undefined.\endaknote
855  /// All panning or spatialization types are honored.
856  /// 3D Spatialization is performed relative to the default listener position (0,0,0) and orientation, where the front vector is (0,0,1) and the top vector is (0,1,0), left handed.
857  /// \return AK_Success if succeeded, AK_InvalidParameter if the input or output configuration is object-based, or AK_Fail if the channel configurations are unknown or unhandled.
859  const AkPositioningData& in_posData, ///< Positioning data. The field "threeD" is ignored if in_posData.behavioral.spatMode is AK_SpatializationMode_None.
860  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
861  AkChannelConfig in_outputConfig, ///< Channel configuration of the output.
862  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
863  ) = 0;
864  };
865 
866  /// Audio device effect plug-in interface. Implement this interface for in-place effects that must be applied at the very end of the pipeline.
867  /// Audio device effects are applied right before sending audio buffers (main mix, passthrough and objects) to the audio device output through IAkSinkPlugin/IAk3DAudioSinkPlugin.
868  /// The format of the audio buffers passed to the effect matches the format requested by the sink plug-in. This means that audio device effects must be in-place; they cannot change io_rFormat in Init().
870  {
871  protected:
872  /// Virtual destructor on interface to avoid warnings.
874 
875  public:
876  /// Audio device effect plug-in initialization. Prepares the effect for data processing, allocates memory and sets up the initial conditions.
877  /// \aknote Memory allocation should be done through appropriate macros (see \ref fx_memory_alloc). \endaknote
878  virtual AKRESULT Init(
879  IAkPluginMemAlloc* in_pAllocator, ///< Interface to memory allocator to be used by the effect
880  IAkAudioDeviceEffectPluginContext* in_pEffectPluginContext, ///< Interface to audio effect's plug-in context
881  IAkPluginParam* in_pParams, ///< Interface to plug-in parameters
882  const AkAudioFormat& in_rFormat, ///< Audio data format of the input/output signal. Matches the channel configuration of the audio device sink plug-in. If format is object-based (AkChannelConfig::eConfigType is Ak_ChannelConfigType_Objects), the plug-in should verify Ak3DAudioSinkCapabilities to determine which inputs it can expect in Execute (main mix, passthrough, objects).
883  const Ak3DAudioSinkCapabilities& in_3dCapabilities ///< 3D capabilities of the output device sink plug-in. If io_rFormat is not object-based, this can be ignored and only the main mix will be submitted to Execute().
884  ) = 0;
885 
886  virtual void Execute(
887  AkAudioBuffer* io_pMainMix, ///< Audio buffer data structure for the main mix (binauralized or not, depending on if binauralization is supported and enabled).
888  AkAudioBuffer* io_pPassthroughMix, ///< The stereo mix to send out to the system in passthrough fashion (no binauralization). NULL if the channel configuration of the device is not object-based or does not have a passthrough.
889  const AkAudioObjects& io_objects, ///< 3D Audio objects and object audio buffers to be consumed. The audio buffers are in the native format of the sound engine (typically float, deinterleaved), as specified by io_rFormat passed to Init(). It is up to the plugin to transform it into a format that is compatible with its output.
890  AkRamp& io_gain ///< Volume gain to apply to all inputs. If the effect applies the gain, it must reset the gain to 1.0f so that it's not applied a second time in the sink plug-in.
891  ) = 0;
892  };
893 
894  /// Interface to retrieve information about an input of a mixer.
895  /// DEPRECATED.
897  {
898  protected:
899  /// Virtual destructor on interface to avoid warnings.
901 
902  public:
903 
904  /// Obtain the parameter blob for the mixer plugin that were attached to this input.
905  /// \return The parameter blob, which can be safely cast into the plugin's implementation.
906  /// If all parameters are default value, NULL is returned. It is up to the plugin's implementation to know
907  /// what the default values are.
908  virtual IAkPluginParam * GetInputParam() = 0;
909 
910  /// Obtain the interface to access the voice info of this input.
911  /// \return The interface to voice info. NULL when the input is not a voice but the output of another bus instead.
913 
914  /// Obtain the interface to access the game object on which the plugin is instantiated.
915  /// \return The interface to GameObject info.
917 
918  /// Query the nature of the connection between this input and the mixer.
919  /// \return The connection type (direct/dry, user-defined auxiliary send, game-defined auxiliary send). Bus inputs are always "direct".
921 
922  /// Use this method to retrieve user data to this context. It is always initialized to NULL until you decide to set it otherwise.
923  /// \return Attached user data.
924  /// \sa SetUserData()
925  virtual void* GetUserData() = 0;
926 
927  /// Use this method to attach user data to this context. It is always initialized to NULL until you decide to set it otherwise.
928  /// \sa GetUserData()
929  virtual void SetUserData(void* in_pUserData) = 0;
930 
931  /// \name Default positioning information.
932  /// \akwarning
933  /// The methods of this group are deprecated.
934  /// \endakwarning
935  //@{
936 
937  /// Retrieve center percentage of this input.
938  /// \return Center percentage, between 0 and 1.
939  virtual AkReal32 GetCenterPerc() = 0;
940 
941  /// Retrieve the speaker panning type: type of panning logic when object is not 3D spatialized.
942  /// Note that the returned value is only relevant when the object is not 3D spatialized,
943  /// that is Get3DSpatializationMode returns AK_SpatializationMode_None.
944  /// \sa
945  /// - Get3DSpatializationMode()
947 
948  /// Speaker panning:
949  /// Retrieve the panner position (each vector component is between -1 and 1) of this input.
950  /// Note that the returned value is only relevant when the object is not 3D spatialized,
951  /// (Get3DSpatializationMode returns AK_SpatializationMode_None), and if speaker panning is not direct assignment
952  /// (GetSpeakerPanningType does not return AK_DirectSpeakerAssignment).
953  /// \sa
954  /// - GetSpeakerPanningType()
955  /// - Get3DSpatializationMode()
956  virtual void GetPannerPosition(
957  AkVector & out_position ///< Returned sound position.
958  ) = 0;
959 
960  /// Get the value of this input's Listener Relative Routing option, that is, if the emitter-listener relative
961  /// association is calculated at this node. Listener Relative Routing needs to be calculated in order for a node
962  /// to be spatialized or attenuated with respect to in-game emitter and listener positions. Otherwise it can only
963  /// be panned.
964  /// \sa
965  /// - Get3DSpatializationMode()
966  /// - Get3DPositionType()
967  /// - GetNum3DPositions()
968  virtual bool HasListenerRelativeRouting() = 0;
969 
970  /// Get whether the emitter position is defined by the game alone (AK_3DPositionType_Emitter), or if it is further automated
971  /// (AK_3DPositionType_EmitterWithAutomation, AK_3DPositionType_ListenerWithAutomation).
972  /// The resulting 3D position(s) may be obtained by Get3DPosition(), and used for 3D spatialization or attenuation.
973  /// \sa
974  /// - Get3DPosition()
975  /// - GetNum3DPositions()
976  /// - HasListenerRelativeRouting()
978 
979  /// 3D spatialization:
980  /// Retrieve the number of emitter-listener pairs (rays) of this input.
981  /// Note that the returned value is always 0 unless the input has listener relative routing (see HasListenerRelativeRouting()).
982  /// Use this function with Get3DPosition().
983  /// \sa
984  /// - Get3DPosition()
985  /// - HasListenerRelativeRouting()
987 
988  /// 3D spatialization:
989  /// Retrieve the spherical coordinates of the desired emitter-listener pair (ray) corresponding to this
990  /// input, as automated by the engine. Applicable only when the input has listener relative routing (see HasListenerRelativeRouting()).
991  /// Returned rays are those that result from engine automation, if applicable.
992  /// \return AK_Success if the pair index is valid, AK_Fail otherwise.
993  /// \sa
994  /// - HasListenerRelativeRouting()
995  /// - GetNum3DPositions()
997  AkUInt32 in_uIndex, ///< Index of the pair, [0, GetNum3DPositions()[
998  AkEmitterListenerPair & out_soundPosition ///< Returned sound position, in spherical coordinates.
999  ) = 0;
1000 
1001  /// 3D spatialization:
1002  /// Evaluate spread value at the distance of the desired emitter-listener pair for this input.
1003  /// Applicable only when the input has listener relative routing (see HasListenerRelativeRouting()).
1004  /// \return The spread value, between 0 and 1. 0 if the pair index is invalid.
1005  /// \sa
1006  /// - HasListenerRelativeRouting()
1007  /// - GetNum3DPositions()
1008  /// - Get3DPosition()
1010  AkUInt32 in_uIndex ///< Index of the pair, [0, GetNum3DPositions()[
1011  ) = 0;
1012 
1013  /// 3D spatialization:
1014  /// Evaluate focus value at the distance of the desired emitter-listener pair for this input.
1015  /// Applicable only when the input has listener relative routing (see HasListenerRelativeRouting()).
1016  /// \return The focus value, between 0 and 1. 0 if the pair index is invalid.
1017  /// \sa
1018  /// - HasListenerRelativeRouting()
1019  /// - GetNum3DPositions()
1020  /// - Get3DPosition()
1022  AkUInt32 in_uIndex ///< Index of the pair, [0, GetNum3DPositions()[
1023  ) = 0;
1024 
1025  /// Get the max distance as defined in the attenuation editor.
1026  /// Applicable only when the input has listener relative routing (see HasListenerRelativeRouting()).
1027  /// \return True if this input has attenuation, false otherwise.
1029  AkReal32 & out_fMaxAttenuationDistance ///< Returned max distance.
1030  ) = 0;
1031 
1032  /// Get next volumes as computed by the sound engine for this input.
1033  /// You may use the returned volume matrices with IAkGlobalPluginContext::MixNinNChannels.
1034  /// \sa IAkGlobalPluginContext
1036  AK::SpeakerVolumes::MatrixPtr out_mxPrevVolumes, ///< Returned in/out channel volume distribution corresponding to the beginning of the buffer. Must be preallocated (see AK::SpeakerVolumes::Matrix services).
1037  AK::SpeakerVolumes::MatrixPtr out_mxNextVolumes ///< Returned in/out channel volume distribution corresponding to the end of the buffer. Must be preallocated (see AK::SpeakerVolumes::Matrix services).
1038  ) = 0;
1039 
1040  /// Query the 3D spatialization mode used by this input.
1041  /// Applicable only when the input has listener relative routing (see HasListenerRelativeRouting()).
1042  /// \return The 3D spatialization mode (see Ak3DSpatializationMode). AK_SpatializationMode_None if not set, or if the input is not a node where the game object is evaluated against its listener.
1043  /// \sa
1044  /// - HasListenerRelativeRouting()
1046 
1047  //@}
1048  };
1049 
1050  /// Interface to retrieve contextual information for a sink plugin.
1051  /// \sa
1052  /// - AK::IAkSinkPlugin
1054  {
1055  protected:
1056  /// Virtual destructor on interface to avoid warnings.
1058 
1059  public:
1060 
1061  /// Query if the sink plugin is instantiated on the main output device (primary tree).
1062  /// \return True if the sink plugin is instantiated on the main output device (primary tree), false otherwise.
1063  /// \sa
1064  /// - AK::IAkSinkPlugin::IsDataNeeded()
1065  /// - AK::IAkSinkPlugin::Consume()
1066  virtual bool IsPrimary() = 0;
1067 
1068  /// Sink plugins may need to call this function to notify the audio thread that it should wake up
1069  /// in order to potentially process an audio frame. Note that the audio thread may wake up for other
1070  /// reasons, for example following calls to AK::SoundEngine::RenderAudio().
1071  /// Once the audio thread is awaken, it will ask the sink plugin how many audio frames need to be
1072  /// processed and presented to the plugin. This is done through AK::IAkSinkPlugin::IsDataNeeded()
1073  /// and AK::IAkSinkPlugin::Consume() respectively.
1074  /// Note that only the sink plugin that is instantiated on the main output device (primary tree) may control
1075  /// the audio thread synchronization.
1076  /// \return AK_Success if the calling plugin is instantiated on the main output device (primary tree),
1077  /// AK_Fail otherwise.
1078  /// \sa
1079  /// - AK::IAkSinkPluginContext::IsPrimary()
1080  /// - AK::IAkSinkPlugin::IsDataNeeded()
1081  /// - AK::IAkSinkPlugin::Consume()
1083 
1084  /// Query engine's user-defined sink queue depth (AkPlatformInitSettings::uNumRefillsInVoice).
1085  /// \return The engine's AkPlatformInitSettings::uNumRefillsInVoice value on platforms for which it exists, 0 otherwise.
1087 
1088  /// Compute the speaker volume matrix of built-in positioning in Wwise from given positioning data and input and output channel configurations.
1089  /// Any known (non-anonymous) combination of configurations will work. For example, ambisonics will be decoded or encoded if needed.
1090  /// \aknote The function will fail if the input or output configuration is object-based, as the speaker volume matrix would be undefined.\endaknote
1091  /// All panning or spatialization types are honored.
1092  /// 3D Spatialization is performed relative to the default listener position (0,0,0) and orientation, where the front vector is (0,0,1) and the top vector is (0,1,0), left handed.
1093  /// \return AK_Success if succeeded, AK_InvalidParameter if the input or output configuration is object-based, or AK_Fail if the channel configurations are unknown or unhandled.
1095  const AkPositioningData& in_posData, ///< Positioning data. The field "threeD" is ignored if in_posData.behavioral.spatMode is AK_SpatializationMode_None.
1096  AkChannelConfig in_inputConfig, ///< Channel configuration of the input.
1097  AkChannelConfig in_outputConfig, ///< Channel configuration of the output.
1098  AK::SpeakerVolumes::MatrixPtr out_mxVolumes ///< Returned volumes matrix. Must be preallocated using AK::SpeakerVolumes::Matrix::GetRequiredSize() (see AK::SpeakerVolumes::Matrix services).
1099  ) = 0;
1100  };
1101 
1103  {
1106  };
1107 
1108  /// Software interface for sink (audio endpoint) plugins.
1109  /// This interface should not be implemented directly,
1110  /// Plug-ins should either implement:
1111  /// - IAkSinkPlugin: for audio endpoint that do not support 3D audio, or
1112  /// - IAk3DAudioSinkPlugin: for audio endpoints that support 3D audio features.
1114  {
1115  public:
1116  /// Initialization of the sink plugin.
1117  ///
1118  /// This method prepares the audio device plug-in for data processing, allocates memory, and sets up initial conditions.
1119  /// The plug-in is passed in a pointer to a memory allocator interface (AK::IAkPluginMemAlloc).You should perform all dynamic memory allocation through this interface using the provided memory allocation macros(refer to \ref fx_memory_alloc).For the most common memory allocation needs, namely allocation at initialization and release at termination, the plug-in does not need to retain a pointer to the allocator.It will also be provided to the plug-in on termination.
1120  /// The AK::IAkSinkPluginContext interface allows to retrieve information related to the context in which the audio device plug-in is operated.
1121  /// The plug-in also receives a pointer to its associated parameter node interface (AK::IAkPluginParam).Most plug-ins will want to keep a reference to the associated parameter node to be able to retrieve parameters at runtime. Refer to \ref iakeffectparam_communication for more details.
1122  /// All of these interfaces will remain valid throughout the plug-in's lifespan so it is safe to keep an internal reference to them when necessary.
1123  /// Plug-ins also receive the output audio format(which stays the same during the lifespan of the plug-in) to be able to allocate memory and setup processing for a given channel configuration.
1124  /// Note that the channel configuration is suggestive and may even be specified as not AkChannelConfig::IsValid().The plugin is free to determine the true channel configuration(this is an io parameter).
1125  ///
1126  /// \return AK_Success if successful.
1127  /// \return AK_NotCompatible if the system doesn't support this sink type. Return this if you want to fall back to the default sinks. This sink will never be requested again. Do not return this code if the device is simply unplugged.
1128  /// \return AK_DeviceNotCompatible if the requested output device doesn't support this sink type. Return this if you want to fall back to the dummy audio sink wich will result in no audio for the associated bus hierachy. This sink will never be requested again.
1129  /// All other return codes will be treated as temporary failures conditions and the sink will be requested again later.
1130 
1131  virtual AKRESULT Init(
1132  IAkPluginMemAlloc * in_pAllocator, ///< Interface to memory allocator to be used by the effect.
1133  IAkSinkPluginContext * in_pSinkPluginContext, ///< Interface to sink plug-in's context.
1134  IAkPluginParam * in_pParams, ///< Interface to plug-in parameters.
1135  AkAudioFormat & io_rFormat ///< Audio data format of the input signal. Note that the channel configuration is suggestive and may even be specified as not AkChannelConfig::IsValid(). The plugin is free to determine the true channel configuration.
1136  ) = 0;
1137 
1138  /// Obtain the number of audio frames that should be processed by the sound engine and presented
1139  /// to this plugin via AK::IAkSinkPlugin::Consume(). The size of a frame is determined by the sound engine and
1140  /// obtainable via AK::IAkPluginContextBase::GetMaxBufferLength().
1141  /// \return AK_Success if successful, AK_Fail if there was a critical error.
1142  /// \sa
1143  /// - AK::IAkSinkPlugin::Consume()
1144  /// - AK::IAkSinkPluginContext::SignalAudioThread()
1146  AkUInt32& out_uNumFramesNeeded ///< Returned number of audio frames needed.
1147  ) = 0;
1148 
1149  /// Called at the end of the audio frame. If no Consume calls were made prior to OnFrameEnd, this means no audio was sent to the device. Assume silence.
1150  /// \sa
1151  /// - AK::IAkSinkPlugin::Consume()
1152  virtual void OnFrameEnd() = 0;
1153 
1154  /// Ask the plug-in whether starvation occurred.
1155  /// \return True if starvation occurred, false otherwise.
1156  virtual bool IsStarved() = 0;
1157 
1158  /// Reset the "starvation" flag after IsStarved() returned true.
1159  virtual void ResetStarved() = 0;
1160 
1162  };
1163 
1164  /// Software interface for sink (audio endpoint) plugins.
1166  {
1167  protected:
1168  /// Virtual destructor on interface to avoid warnings.
1169  virtual ~IAkSinkPlugin() {}
1170 
1171  public:
1172  /// Present an audio buffer to the sink. The audio buffer is in the native format of the sound engine
1173  /// (typically float, deinterleaved), as specified by io_rFormat passed to Init(). It is up to the
1174  /// plugin to transform it into a format that is compatible with its output.
1175  /// Note that Consume() is not called if the output for this frame consists of silence. Plugins should
1176  /// detect this in OnFrameEnd().
1177  /// \sa
1178  /// - AK::IAkSinkPlugin::IsDataNeeded()
1179  /// - AK::IAkSinkPlugin::OnFrameEnd()
1180  virtual void Consume(
1181  AkAudioBuffer * in_pInputBuffer, ///< Input audio buffer data structure. Plugins should avoid processing data in-place.
1182  AkRamp in_gain ///< Volume gain to apply to this input (prev corresponds to the beginning, next corresponds to the end of the buffer).
1183  ) = 0;
1184 
1185  virtual AkSinkPluginType GetSinkPluginType() const override final { return AkSinkPluginType_Sink; }
1186  };
1187 
1188  /// Software plug-in interface for sink (audio end point) which supports 3D audio features.
1190  {
1191  protected:
1192  /// Virtual destructor on interface to avoid warnings.
1194 
1195  public:
1196  /// Returns the capabilities of the sink's 3D audio system
1198  Ak3DAudioSinkCapabilities& out_rCapabilities ///< Capabilities of the 3D Audio system
1199  ) = 0;
1200 
1201  /// Same as AK::IAkSinkPlugin::Consume(), but receives 3 inputs: the main mix,the stereo passthrough and 3d audio objects.
1202  /// \sa
1203  /// - AK::IAkSinkPlugin::Consume()
1204  /// - AK::IAkSinkPlugin::IsDataNeeded()
1205  /// - AK::IAkSinkPlugin::OnFrameEnd()
1206  virtual void Consume(
1207  AkAudioBuffer* in_pMainMix, ///< Audio buffer data structure for the main mix (binauralized or not, depending on if binauralization is supported and enabled).
1208  AkAudioBuffer* in_pPassthroughMix, ///< The stereo mix to send out to the system in passthrough fashion (no binauralization). NULL if the channel configuration of the device is not object-based or does not have a passthrough.
1209  const AkAudioObjects& in_objects, ///< 3D Audio objects and object audio buffers to be consumed. The audio buffers are in the native format of the sound engine (typically float, deinterleaved), as specified by io_rFormat passed to Init(). It is up to the plugin to transform it into a format that is compatible with its output.
1210  AkRamp in_gain ///< Volume gain to apply to all inputs.
1211  ) = 0;
1212 
1213  virtual AkSinkPluginType GetSinkPluginType() const override final { return AkSinkPluginType_3DAudioSink; }
1214  };
1215 
1216  /// Wwise sound engine source plug-in interface (see \ref soundengine_plugins_source).
1217  class IAkSourcePlugin : public IAkPlugin
1218  {
1219  protected:
1220  /// Virtual destructor on interface to avoid warnings.
1221  virtual ~IAkSourcePlugin(){}
1222 
1223  public:
1224  /// Source plug-in initialization. Gets the plug-in ready for data processing, allocates memory and sets up the initial conditions.
1225  /// \aknote Memory allocation should be done through the appropriate macros (see \ref fx_memory_alloc). \endaknote
1226  /// \sa
1227  /// - \ref iaksourceeffect_init
1228  virtual AKRESULT Init(
1229  IAkPluginMemAlloc * in_pAllocator, ///< Interface to the memory allocator to be used by the plug-in
1230  IAkSourcePluginContext * in_pSourcePluginContext, ///< Interface to the source plug-in's context
1231  IAkPluginParam * in_pParams, ///< Interface to the plug-in parameters
1232  AkAudioFormat & io_rFormat ///< Audio format of the output data to be produced by the plug-in (mono native by default)
1233  ) = 0;
1234 
1235  /// This method is called to determine the approximate duration of the source.
1236  /// \return The duration of the source, in milliseconds.
1237  /// \sa
1238  /// - \ref iaksourceeffect_getduration
1239  virtual AkReal32 GetDuration() const = 0;
1240 
1241  /// This method is called to determine the estimated envelope of the source.
1242  /// \return The estimated envelope of the data that will be generated in the next call to
1243  /// Execute(). The envelope value should be normalized to the highest peak of the entire
1244  /// duration of the source. Expected range is [0,1]. If envelope and peak value cannot be
1245  /// predicted, the source should return 1 (no envelope).
1246  /// \sa
1247  /// - \ref iaksourceeffect_getenvelope
1248  virtual AkReal32 GetEnvelope() const
1249  {
1250  return 1.f;
1251  }
1252 
1253  /// This method is called to tell the source to stop looping.
1254  /// This will typically be called when an action of type "break" will be triggered on the playing source.
1255  /// Break (or StopLooping) means: terminate gracefully... if possible. In most situations it finishes the current loop and plays the sound release if there is one.
1256  ///
1257  /// \return
1258  /// - AK_Success if the source ignores the break command and plays normally till the end or if the source support to stop looping and terminates gracefully.
1259  /// - AK_Fail if the source cannot simply stop looping, in this situation, the break command will end up stopping this source.
1260  /// \sa
1261  /// - \ref iaksourceeffect_stoplooping
1262  virtual AKRESULT StopLooping(){ return AK_Success; }
1263 
1264  /// This method is called to tell the source to seek to an arbitrary sample.
1265  /// This will typically be called when the game calls AK::SoundEngine::SeekOnEvent() where the event plays
1266  /// a sound that wraps this source plug-in.
1267  /// If the plug-in does not handle seeks, it should return AK_Success. If it returns AK_Fail, it will
1268  /// be terminated by the sound engine.
1269  ///
1270  /// \return
1271  /// - AK_Success if the source handles or ignores seek command.
1272  /// - AK_Fail if the source considers that seeking requests should provoke termination, for example, if
1273  /// the desired position is greater than the prescribed source duration.
1274  /// \sa
1275  /// - AK::SoundEngine::SeekOnEvent()
1276  virtual AKRESULT Seek(
1277  AkUInt32 /* in_uPosition */ ///< Position to seek to, in samples, at the rate specified in AkAudioFormat (see AK::IAkSourcePlugin::Init()).
1278  ) { return AK_Success; }
1279 
1280  /// Skips execution when the voice is virtual playing from elapsed time to simulate processing that would have taken place (e.g. update internal state) while
1281  /// avoiding most of the CPU hit of plug-in execution.
1282  /// Given the number of frames requested adjust the number of frames that would have been produced by a call to Execute() in the io_uFrames parameter and return and
1283  /// return AK_DataReady or AK_NoMoreData, depending if there would be audio output or not at that point.
1284  /// Returning AK_NotImplemented will trigger a normal execution of the voice (as if it was not virtual) thus not enabling the CPU savings of a proper from elapsed time behavior.
1285  /// Note that returning AK_NotImplemeted for a source plug-ins that support asynchronous processing will produce a 'resume' virtual voice behavior instead.
1287  AkUInt32 & /*io_uFrames */ ///< (Input) Number of frames that the audio buffer processing can advance (equivalent to MaxFrames()). The output value should be the number of frames that would be produced this execution.
1288  ) { return AK_NotImplemented; }
1289 
1290  /// Software effect plug-in DSP execution.
1291  /// \aknote The effect can output as much as wanted up to MaxFrames(). All sample frames passed uValidFrames at input time are
1292  /// not initialized and it is the responsibility of the effect to do so. When modifying the number of valid frames within execution
1293  /// (e.g. to flush delay lines) the effect should notify the pipeline by updating uValidFrames accordingly.
1294  /// \aknote The effect will stop being called by the pipeline when AK_NoMoreData is returned in the the eState field of the AkAudioBuffer structure.
1295  virtual void Execute(
1296  AkAudioBuffer * io_pBuffer ///< In/Out audio buffer data structure (in-place processing)
1297  ) = 0;
1298  };
1299 
1300 
1301  /// This function can be useful to convert from normalized floating point audio samples to HW-pipeline format samples.
1302  #define AK_FLOAT_TO_SAMPLETYPE( __in__ ) (__in__)
1303  /// This function can be useful to convert from normalized floating point audio samples to HW-pipeline format samples when the input is not not to exceed (-1,1) range.
1304  #define AK_FLOAT_TO_SAMPLETYPE_NOCLIP( __in__ ) (__in__)
1305  /// This function can be useful to convert from HW-pipeline format samples to normalized floating point audio samples.
1306  #define AK_SAMPLETYPE_TO_FLOAT( __in__ ) (__in__)
1307 
1308  #define AK_DBTOLIN( __db__ ) (powf(10.f,(__db__) * 0.05f))
1309 }
1310 
1311 /// Registered plugin creation function prototype.
1313 /// Registered plugin parameter node creation function prototype.
1315 /// Registered plugin device enumeration function prototype, used for providing lists of devices by plug-ins.
1317  AkUInt32& io_maxNumDevices, ///< In: The length of the out_deviceDescriptions array, or zero is out_deviceDescriptions is null. Out: If out_deviceDescriptions is not-null, this should be set to the number of entries in out_deviceDescriptions that was populated (and should be less-than-or-equal to the initial value). If out_deviceDescriptions is null, this should be set to the maximum number of devices that may be returned by this callback.
1318  AkDeviceDescription* out_deviceDescriptions ///< The output array of device descriptions. If this is not-null, there will be a number of entries equal to the input value of io_maxNumDevices.
1319  );
1320 
1321 struct AkPlatformInitSettings;
1322 struct AkInitSettings;
1323 
1324 namespace AK
1325 {
1327  {
1330  };
1331 
1332  /// Common interface for plug-in services accessed through the global plug-in context
1334  {
1335  protected:
1336  virtual ~IAkPluginService() {}
1337  };
1338 
1339  /// Global plug-in context used for plug-in registration/initialization.
1340  /// Games query this interface from the sound engine, via AK::SoundEngine::GetGlobalPluginContext. Plug-ins query it via IAkPluginContextBase::GlobalContext.
1342  {
1343  protected:
1344  /// Virtual destructor on interface to avoid warnings.
1346 
1347  public:
1348 
1349  /// Retrieve the streaming manager access interface.
1350  virtual IAkStreamMgr * GetStreamMgr() const = 0;
1351 
1352  /// Retrieve the maximum number of frames that Execute() will be called with for this effect.
1353  /// Can be used by the effect to make memory allocation at initialization based on this worst case scenario.
1354  /// \return Maximum number of frames.
1355  virtual AkUInt16 GetMaxBufferLength() const = 0;
1356 
1357  /// Query whether sound engine is in real-time or offline (faster than real-time) mode.
1358  /// \return true when sound engine is in offline mode, false otherwise.
1359  virtual bool IsRenderingOffline() const = 0;
1360 
1361  /// Retrieve the core sample rate of the engine. This sample rate applies to all effects except source plugins, which declare their own sample rate.
1362  /// \return Core sample rate.
1363  virtual AkUInt32 GetSampleRate() const = 0;
1364 
1365  /// Post a monitoring message or error string. This will be displayed in the Wwise capture
1366  /// log.
1367  /// \return AK_Success if successful, AK_Fail if there was a problem posting the message.
1368  /// In optimized mode, this function returns AK_NotCompatible.
1369  /// \remark This function is provided as a tracking tool only. It does nothing if it is
1370  /// called in the optimized/release configuration and return AK_NotCompatible.
1372  const char* in_pszError, ///< Message or error string to be displayed
1373  AK::Monitor::ErrorLevel in_eErrorLevel ///< Specifies whether it should be displayed as a message or an error
1374  ) = 0;
1375 
1376  /// Register a plug-in with the sound engine and set the callback functions to create the
1377  /// plug-in and its parameter node.
1378  /// \sa
1379  /// - \ref register_effects
1380  /// - \ref plugin_xml
1381  /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
1382  /// - Insufficient memory to register the plug-in
1383  /// - Plug-in ID already registered
1384  /// \remarks
1385  /// Codecs and plug-ins must be registered before loading banks that use them.\n
1386  /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
1387  /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in
1388  /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects,
1389  /// posting the event will fail.
1391  AkPluginType in_eType, ///< Plug-in type (for example, source or effect)
1392  AkUInt32 in_ulCompanyID, ///< Company identifier (as declared in the plug-in description XML file)
1393  AkUInt32 in_ulPluginID, ///< Plug-in identifier (as declared in the plug-in description XML file)
1394  AkCreatePluginCallback in_pCreateFunc, ///< Pointer to the plug-in's creation function
1395  AkCreateParamCallback in_pCreateParamFunc ///< Pointer to the plug-in's parameter node creation function
1396  ) = 0;
1397 
1398  /// Register a codec type with the sound engine and set the callback functions to create the
1399  /// codec's file source and bank source nodes.
1400  /// \sa
1401  /// - \ref register_effects
1402  /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided, or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
1403  /// - Insufficient memory to register the codec
1404  /// - Codec ID already registered
1405  /// \remarks
1406  /// Codecs and plug-ins must be registered before loading banks that use them.\n
1407  /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
1408  /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in
1409  /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects,
1410  /// posting the event will fail.
1412  AkUInt32 in_ulCompanyID, ///< Company identifier (as declared in XML)
1413  AkUInt32 in_ulPluginID, ///< Plugin identifier (as declared in XML)
1414  AkCreateFileSourceCallback in_pFileCreateFunc, ///< Factory for streaming sources.
1415  AkCreateBankSourceCallback in_pBankCreateFunc ///< Factory for in-memory sources.
1416  ) = 0;
1417 
1418  /// Register a global callback function. This function will be called from the audio rendering thread, at the
1419  /// location specified by in_eLocation. This function will also be called from the thread calling
1420  /// AK::SoundEngine::Term with in_eLocation set to AkGlobalCallbackLocation_Term.
1421  /// For example, in order to be called at every audio rendering pass, and once during teardown for releasing resources, you would call
1422  /// RegisterGlobalCallback(AkPluginTypeEffect, MY_COMPANY_ID , MY_PLUGIN_ID, myCallback, AkGlobalCallbackLocation_BeginRender | AkGlobalCallbackLocation_Term, myCookie);
1423  /// \remarks
1424  /// A valid (not AkPluginTypeNone) Plugin Type, Company ID and valid (non-zero) Plug-in ID of the plug-in registering the callback must be provided to this function.
1425  /// The timing of the callback function will contribute to the timing of the plug-in registered (Total Plug-in CPU and Advanced Profiler Plug-in tab).
1426  /// Timers will be registered to callbacks at all locations except for \c AkGlobalCallbackLocation::AkGlobalCallbackLocation_Register and \c AkGlobalCallbackLocation::AkGlobalCallbackLocation_Term.
1427  /// It is only legal to call this function from inside the plug-in registration callback, exclusively when receiving \c AkGlobalCallbackLocation::AkGlobalCallbackLocation_Register.
1428  /// This function should not be called from inside the plug-in instance (e.g. in Init, Execute, etc.) to prevent deadlocks when processing plug-ins in parallel.
1429  /// It is illegal to call this function while already inside of a registered global callback.
1430  /// This function might stall for several milliseconds before returning.
1431  /// \sa
1432  /// - \ref fx_global_hooks
1433  /// - AK::IAkGlobalPluginContext::UnregisterGlobalCallback()
1434  /// - AkGlobalCallbackFunc
1435  /// - AkGlobalCallbackLocation
1437  AkPluginType in_eType, ///< A valid Plug-in type (for example, source or effect).
1438  AkUInt32 in_ulCompanyID, ///< Company identifier (as declared in the plug-in description XML file).
1439  AkUInt32 in_ulPluginID, ///< Plug-in identifier (as declared in the plug-in description XML file).
1440  AkGlobalCallbackFunc in_pCallback, ///< Function to register as a global callback.
1441  AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender, ///< Callback location defined in AkGlobalCallbackLocation. Bitwise OR multiple locations if needed.
1442  void * in_pCookie = NULL ///< User cookie.
1443  ) = 0;
1444 
1445  /// Unregister a global callback function, previously registered using RegisterGlobalCallback.
1446  /// \remarks
1447  /// It is only legal to call this function from inside the plug-in registration global callback, exclusively when receiving \c AkGlobalCallbackLocation::AkGlobalCallbackLocation_Term.
1448  /// This function should not be called from inside the plug-in instance (e.g. in Init, Execute, etc.) to prevent deadlocks when processing plug-ins in parallel.
1449  /// It is illegal to call this function while already inside of a registered global callback.
1450  /// This function might stall for several milliseconds before returning.
1451  /// \sa
1452  /// - \ref fx_global_hooks
1453  /// - AK::IAkGlobalPluginContext::RegisterGlobalCallback()
1454  /// - AkGlobalCallbackFunc
1455  /// - AkGlobalCallbackLocation
1457  AkGlobalCallbackFunc in_pCallback, ///< Function to unregister as a global callback.
1458  AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender ///< Must match in_eLocation as passed to RegisterGlobalCallback for this callback.
1459  ) = 0;
1460 
1461  /// Get the default allocator for plugins. This is useful for performing global initialization tasks shared across multiple plugin instances.
1463 
1464  /// \sa SetRTPCValue
1466  AkRtpcID in_rtpcID, ///< ID of the game parameter
1467  AkRtpcValue in_value, ///< Value to set
1468  AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
1469  AkTimeMs in_uValueChangeDuration = 0, ///< Duration during which the game parameter is interpolated towards in_value
1470  AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear, ///< Curve type to be used for the game parameter interpolation
1471  bool in_bBypassInternalValueInterpolation = false ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
1472  ) = 0;
1473 
1474  /// Send custom game data to a plugin that resides on a bus (insert effect or mixer plugin).
1475  /// Data will be copied and stored into a separate list.
1476  /// Previous entry is deleted when a new one is sent.
1477  /// Set the data pointer to NULL to clear item from the list.
1478  /// This means that you cannot send different data to various instances of the plugin on a same bus.\endaknote
1479  /// \return AK_Success if data was sent successfully.
1481  AkUniqueID in_busID, ///< Bus ID
1482  AkGameObjectID in_busObjectID, ///< Bus Object ID
1483  AkPluginType in_eType, ///< Plug-in type (for example, source or effect)
1484  AkUInt32 in_uCompanyID, ///< Company identifier (as declared in the plug-in description XML file)
1485  AkUInt32 in_uPluginID, ///< Plug-in identifier (as declared in the plug-in description XML file)
1486  const void* in_pData, ///< The data blob
1487  AkUInt32 in_uSizeInBytes ///< Size of data
1488  ) = 0;
1489 
1490  /// Computes gain vector for encoding a source with angles in_fAzimuth and in_fElevation to full-sphere ambisonics with order in_uOrder.
1491  /// Ambisonic channels are ordered by ACN and use the SN3D convention.
1493  AkReal32 in_fAzimuth, ///< Incident angle, in radians [-pi,pi], where 0 is the front (positive values are clockwise).
1494  AkReal32 in_fElevation, ///< Incident angle, in radians [-pi/2,pi/2], where 0 is the azimuthal plane.
1495  AkChannelConfig in_cfgAmbisonics, ///< Determines number of gains in vector out_vVolumes.
1496  AK::SpeakerVolumes::VectorPtr out_vVolumes ///< Returned volumes (see AK::SpeakerVolumes::Vector services). Must be allocated prior to calling this function with the size returned by AK::SpeakerVolumes::Vector::GetRequiredSize() for the desired number of channels.
1497  ) = 0;
1498 
1499  /// Computes gain matrix for decoding an SN3D-normalized ACN-ordered ambisonic signal of order sqrt(in_cfgAmbisonics.uNumChannels)-1, with max-RE weighting function, on a (regularly) sampled sphere whose samples in_samples are
1500  /// expressed in left-handed cartesian coordinates, with unitary norm.
1501  /// This decoding technique is optimal for regular sampling.
1502  /// The returned matrix has in_cfgAmbisonics.uNumChannels inputs (rows) and in_uNumSamples outputs (columns), and is normalized by the number of samples.
1503  /// You may use the returned volume matrix with IAkPluginServiceMixer::MixNinNChannels.
1504  /// Supported ambisonic configurations are full-sphere 1st to 5th order.
1505  /// \return AK_Fail when ambisonic configuration. AK_Success otherwise.
1507  const AkVector in_samples[], ///< Array of vector samples expressed in left-handed cartesian coordinates, where (1,0,0) points towards the right and (0,1,0) points towards the top. Vectors must be normalized.
1508  AkUInt32 in_uNumSamples, ///< Number of points in in_samples.
1509  AkChannelConfig in_cfgAmbisonics, ///< Ambisonic configuration. Supported configurations are 1st to 5th order. Determines number of rows (input channels) in matrix out_mxVolume.
1510  AK::SpeakerVolumes::MatrixPtr out_mxVolume ///< Returned volume matrix of in_cfgAmbisonics.uNumChannels rows x in_uNumSamples colums. Must be allocated prior to calling this function with the size returned by AK::SpeakerVolumes::Matrix::GetRequiredSize() for the desired number of channels.
1511  ) = 0;
1512 
1513  /// Return an acoustic texture.
1514  /// \return The pointer to an acoustic texture if successful, NULL otherwise.
1516  AkAcousticTextureID in_AcousticTextureID ///< Acoustic Texture's ID
1517  ) = 0;
1518 
1519  /// Given an emitter-listener pair, compute the azimuth and elevation angles of the emitter relative to the listener.
1520  /// \return AK_Success if the listener referenced in the emitter-listener pair was found; azimuth and elevation.
1522  const AkEmitterListenerPair & in_pair, ///< Emitter-listener pair for which to compute azimuth and elevation angles.
1523  AkReal32 & out_fAzimuth, ///< Returned azimuthal angle, in radians.
1524  AkReal32 & out_fElevation ///< Returned elevation angle, in radians.
1525  ) const = 0;
1526 
1527  /// Get the platform init settings that the wwise sound engine has been initialized with.
1528  /// This function returns a null pointer if called with an instance of RenderFXGlobalContext.
1530 
1531  /// Get the init settings that the wwise sound engine has been initialized with
1532  /// This function returns a null pointer if called with an instance of RenderFXGlobalContext.
1533  virtual const AkInitSettings* GetInitSettings() const = 0;
1534 
1535  /// Gets the configured audio settings.
1536  /// Call this function to get the configured audio settings.
1537  ///
1538  /// \warning This function is not thread-safe.
1539  /// \warning Call this function only after the sound engine has been properly initialized.
1541  AkAudioSettings & out_audioSettings ///< Returned audio settings
1542  ) const = 0;
1543 
1544  /// Universal converter from string to ID for the sound engine.
1545  /// Calls AK::SoundEngine::GetIDFromString.
1546  /// \sa
1547  /// - <tt>AK::SoundEngine::GetIDFromString</tt>
1548  virtual AkUInt32 GetIDFromString(const char* in_pszString) const = 0;
1549 
1550  /// Synchronously posts an Event to the sound engine (by event ID).
1551  /// The callback function can be used to be noticed when markers are reached or when the event is finished.
1552  /// An array of wave file sources can be provided to resolve External Sources triggered by the event.
1553  /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
1554  /// \remarks
1555  /// This function executes the actions contained in the event without going through the message queue.
1556  /// In order to do so it acquires the global Wwise sound engine lock. It should therefore only be called from one of the
1557  /// global engine hooks (see AK::IAkGlobalPluginContext::RegisterGlobalCallback).
1558  /// Use AK::IAkGlobalPluginContext::GetIDFromString() if you use event names (strings).
1559  /// \sa
1560  /// - <tt>AK::SoundEngine::PostEvent</tt>
1561  /// - <tt>AK::IAkGlobalPluginContext::RegisterGlobalCallback</tt>
1562  /// - <tt>AK::IAkGlobalPluginContext::GetIDFromString</tt>
1564  AkUniqueID in_eventID, ///< Unique ID of the event
1565  AkGameObjectID in_gameObjectID, ///< Associated game object ID
1566  AkUInt32 in_uFlags = 0, ///< Bitmask: see \ref AkCallbackType
1567  AkCallbackFunc in_pfnCallback = NULL, ///< Callback function
1568  void * in_pCookie = NULL, ///< Callback cookie that will be sent to the callback function along with additional information
1569  AkUInt32 in_cExternals = 0, ///< Optional count of external source structures
1570  AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
1571  AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID///< Optional (advanced users only) Specify the playing ID to target with the event. Will Cause active actions in this event to target an existing Playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any for normal playback.
1572  ) = 0;
1573 
1574  /// Executes a number of MIDI Events on all nodes that are referenced in the specified Event in an Action of type Play.
1575  /// Each MIDI event will be posted in AkMIDIPost::uOffset samples from the start of the current frame. The duration of
1576  /// a sample can be determined from the sound engine's audio settings, via a call to AK::IAkGlobalPluginContext::GetAudioSettings.
1577  /// \remarks
1578  /// This function executes the MIDI Events without going through the message queue.
1579  /// In order to do so it acquires the global Wwise sound engine lock. It should therefore only be called from one of the
1580  /// global engine hooks (see AK::IAkGlobalPluginContext::RegisterGlobalCallback).
1581  /// Use AK::IAkGlobalPluginContext::GetIDFromString() if you use event names (strings).
1582  /// \sa
1583  /// - <tt>AK::SoundEngine::PostMIDIOnEvent</tt>
1584  /// - <tt>AK::IAkGlobalPluginContext::GetAudioSettings</tt>
1585  /// - <tt>AK::IAkGlobalPluginContext::StopMIDIOnEventSync</tt>
1586  /// - <tt>AK::IAkGlobalPluginContext::RegisterGlobalCallback</tt>
1587  /// - <tt>AK::IAkGlobalPluginContext::GetIDFromString</tt>
1589  AkUniqueID in_eventID, ///< Unique ID of the Event
1590  AkGameObjectID in_gameObjectID, ///< Associated game object ID
1591  AkMIDIPost* in_pPosts, ///< MIDI Events to post
1592  AkUInt16 in_uNumPosts, ///< Number of MIDI Events to post
1593  bool in_bAbsoluteOffsets = false, ///< Whether AkMIDIPost::uOffset values are relative to current frame or absolute
1594  AkUInt32 in_uFlags = 0, ///< Bitmask: see \ref AkCallbackType
1595  AkCallbackFunc in_pfnCallback = NULL, ///< Callback function
1596  void * in_pCookie = NULL, ///< Callback cookie that will be sent to the callback function along with additional information
1597  AkPlayingID in_playingID = AK_INVALID_PLAYING_ID ///< Target playing ID
1598  ) = 0;
1599 
1600  /// Stops MIDI notes on all nodes that are referenced in the specified event in an action of type play,
1601  /// with the specified Game Object. Invalid parameters are interpreted as wildcards. For example, calling
1602  /// this function with in_eventID set to AK_INVALID_UNIQUE_ID will stop all MIDI notes for Game Object
1603  /// in_gameObjectID.
1604  /// \remarks
1605  /// This function stops the MIDI notes without going through the message queue.
1606  /// In order to do so it acquires the global Wwise sound engine lock. It should therefore only be called from one of the
1607  /// global engine hooks (see AK::IAkGlobalPluginContext::RegisterGlobalCallback).
1608  /// Use AK::IAkGlobalPluginContext::GetIDFromString() if you use event names (strings).
1609  /// \sa
1610  /// - <tt>AK::IAkGlobalPluginContext::PostMIDIOnEvent</tt>
1611  /// - <tt>AK::IAkGlobalPluginContext::GetIDFromString</tt>
1613  AkUniqueID in_eventID = AK_INVALID_UNIQUE_ID, ///< Unique ID of the Event
1614  AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT, ///< Associated game object ID
1615  AkPlayingID in_playingID = AK_INVALID_PLAYING_ID ///< Target playing ID
1616  ) = 0;
1617 
1618  /// \return The gateway to platform-specific functionality
1619  /// \sa IAkPlatformContext
1621 
1622  /// Retrieves a plug-in service to provide specific "helper" functionality. Note that each service should provide
1623  /// macros that handle the casting to the appropriate service, and are recommended instead of calling this directly.
1624  /// Note that all plug-in service are statically allocated, and any references to them can be cached without lifetime checks.
1626  AkPluginServiceType in_pluginService ///< Enum value for the specific plug-in service to fetch
1627  ) const = 0;
1628 
1629  /// Obtains the current audio output buffer tick. This corresponds to the number of buffers produced by
1630  /// the sound engine since initialization.
1631  /// \return Tick count.
1632  virtual AkUInt32 GetBufferTick() const = 0;
1633  };
1634 
1635  /// Interface for the "Mixer" plug-in service, to handle mixing together of signals, or applying simple transforms
1637  {
1638  protected:
1640  public:
1641  /// N to N channels mix
1642  virtual void MixNinNChannels(
1643  AkAudioBuffer* in_pInputBuffer, ///< Input multichannel buffer.
1644  AkAudioBuffer* in_pMixBuffer, ///< Multichannel buffer with which the input buffer is mixed.
1645  AkReal32 in_fPrevGain, ///< Gain, corresponding to the beginning of the buffer, to apply uniformly to each mixed channel.
1646  AkReal32 in_fNextGain, ///< Gain, corresponding to the end of the buffer, to apply uniformly to each mixed channel.
1647  AK::SpeakerVolumes::ConstMatrixPtr in_mxPrevVolumes,///< In/out channel volume distribution corresponding to the beginning of the buffer (see AK::SpeakerVolumes::Matrix services).
1648  AK::SpeakerVolumes::ConstMatrixPtr in_mxNextVolumes ///< In/out channel volume distribution corresponding to the end of the buffer (see AK::SpeakerVolumes::Matrix services).
1649  ) = 0;
1650 
1651  /// 1 to N channels mix
1652  virtual void Mix1inNChannels(
1653  AkReal32* AK_RESTRICT in_pInChannel, ///< Input channel buffer.
1654  AkAudioBuffer* in_pMixBuffer, ///< Multichannel buffer with which the input buffer is mixed.
1655  AkReal32 in_fPrevGain, ///< Gain, corresponding to the beginning of the input channel.
1656  AkReal32 in_fNextGain, ///< Gain, corresponding to the end of the input channel.
1657  AK::SpeakerVolumes::ConstVectorPtr in_vPrevVolumes, ///< Output channel volume distribution corresponding to the beginning of the buffer (see AK::SpeakerVolumes::Vector services).
1658  AK::SpeakerVolumes::ConstVectorPtr in_vNextVolumes ///< Output channel volume distribution corresponding to the end of the buffer (see AK::SpeakerVolumes::Vector services).
1659  ) = 0;
1660 
1661  /// Single channel mix
1662  virtual void MixChannel(
1663  AkReal32* AK_RESTRICT in_pInBuffer, ///< Input channel buffer.
1664  AkReal32* AK_RESTRICT in_pOutBuffer, ///< Output channel buffer.
1665  AkReal32 in_fPrevGain, ///< Gain, corresponding to the beginning of the input channel.
1666  AkReal32 in_fNextGain, ///< Gain, corresponding to the end of the input channel.
1667  AkUInt16 in_uNumFrames ///< Number of frames to mix.
1668  ) = 0;
1669 
1670  /// Given non-interleaved audio in the provided in_pInputBuffer, will apply a ramping gain over the number
1671  /// of frames specified, and store the result in in_pOutputBuffer. Channel data from in_pInputBuffer will also be
1672  /// interleaved in in_pOutputBuffer's results, and optionally converted from 32-bit floats to 16-bit integers.
1674  AkAudioBuffer* in_pInputBuffer, ///< Input audioBuffer data
1675  AkAudioBuffer* in_pOutputBuffer, ///< Output audioBuffer data
1676  AkRamp in_gain, ///< Ramping gain to apply over duration of buffer
1677  bool in_convertToInt16 ///< Whether the input data should be converted to int16
1678  ) const = 0;
1679 
1680  /// Given non-interleaved audio in the provided in_pInputBuffer, will apply a ramping gain over the number
1681  /// of frames specified, and store the result in in_pOutputBuffer. Audio data in in_pOutputBuffer will have
1682  /// the same layout as in_pInputBuffer, and optionally converted from 32-bit floats to 16-bit integers.
1683  virtual void ApplyGain(
1684  AkAudioBuffer* in_pInputBuffer, ///< Input audioBuffer data
1685  AkAudioBuffer* in_pOutputBuffer, ///< Output audioBuffer data
1686  AkRamp in_gain, ///< Ramping gain to apply over duration of buffer
1687  bool in_convertToInt16 ///< Whether the input data should be converted to int16
1688  ) const = 0;
1689  };
1690 
1691  #define AK_GET_PLUGIN_SERVICE_MIXER(plugin_ctx) static_cast<AK::IAkPluginServiceMixer*>(plugin_ctx->GetPluginService(AK::PluginServiceType_Mixer))
1692 
1693  /// This class takes care of the registration of plug-ins in the Wwise engine. Plug-in developers must provide one instance of this class for each plug-in.
1694  /// \sa
1695  /// - \ref soundengine_plugins
1697  {
1698  public:
1700  AkUInt32 in_ulCompanyID, ///< Plugin company ID.
1701  AkUInt32 in_ulPluginID ///< Plugin ID.
1702  )
1703  {
1704  // Placeholder used for plug-in extensions (plug-ins that modify the behavior of an existing plug-in without registering a new ID)
1705  }
1706 
1708  AkPluginType in_eType, ///< Plugin type.
1709  AkUInt32 in_ulCompanyID, ///< Plugin company ID.
1710  AkUInt32 in_ulPluginID, ///< Plugin ID.
1711  AkCreatePluginCallback in_pCreateFunc, ///< Plugin object factory.
1712  AkCreateParamCallback in_pCreateParamFunc, ///< Plugin parameter object factory.
1713  AkGlobalCallbackFunc in_pRegisterCallback = NULL, ///< Optional callback function called after successful plugin registration, with argument AkGlobalCallbackLocation_Register.
1714  void * in_pRegisterCallbackCookie = NULL ///< Optional cookie passed to register callback function above.
1715  )
1717  , m_eType(in_eType)
1718  , m_ulCompanyID(in_ulCompanyID)
1719  , m_ulPluginID(in_ulPluginID)
1720  , m_pCreateFunc(in_pCreateFunc)
1721  , m_pCreateParamFunc(in_pCreateParamFunc)
1722  , m_pFileCreateFunc(NULL) // Legacy
1723  , m_pBankCreateFunc(NULL) // Legacy
1724  , m_pRegisterCallback(in_pRegisterCallback)
1725  , m_pRegisterCallbackCookie(in_pRegisterCallbackCookie)
1727  , m_CodecDescriptor{ nullptr, nullptr, nullptr, nullptr }
1728  {
1729  g_pAKPluginList = this;
1730  }
1731 
1733  AkPluginType in_eType, ///< Plugin type.
1734  AkUInt32 in_ulCompanyID, ///< Plugin company ID.
1735  AkUInt32 in_ulPluginID, ///< Plugin ID.
1736  AkCreatePluginCallback in_pCreateFunc, ///< Plugin object factory.
1737  AkCreateParamCallback in_pCreateParamFunc, ///< Plugin parameter object factory.
1738  AkGetDeviceListCallback in_pGetDeviceListFunc, ///< Plugin parameter object factory.
1739  AkGlobalCallbackFunc in_pRegisterCallback = NULL, ///< Optional callback function called after successful plugin registration, with argument AkGlobalCallbackLocation_Register.
1740  void * in_pRegisterCallbackCookie = NULL ///< Optional cookie passed to register callback function above.
1741  )
1743  , m_eType(in_eType)
1744  , m_ulCompanyID(in_ulCompanyID)
1745  , m_ulPluginID(in_ulPluginID)
1746  , m_pCreateFunc(in_pCreateFunc)
1747  , m_pCreateParamFunc(in_pCreateParamFunc)
1748  , m_pFileCreateFunc(NULL) // Legacy
1749  , m_pBankCreateFunc(NULL) // Legacy
1750  , m_pRegisterCallback(in_pRegisterCallback)
1751  , m_pRegisterCallbackCookie(in_pRegisterCallbackCookie)
1752  , m_pGetDeviceListFunc(in_pGetDeviceListFunc)
1753  , m_CodecDescriptor{ nullptr, nullptr, nullptr, nullptr }
1754  {
1755  g_pAKPluginList = this;
1756  }
1757 
1759  AkUInt32 in_ulCompanyID, ///< Plugin company ID.
1760  AkUInt32 in_ulPluginID, ///< Plugin ID.
1761  AkCreateFileSourceCallback in_pCreateFile, ///< Streamed source factory.
1762  AkCreateBankSourceCallback in_pCreateBank) ///< In-memory source factory.
1765  , m_ulCompanyID(in_ulCompanyID)
1766  , m_ulPluginID(in_ulPluginID)
1767  , m_pCreateFunc(NULL)
1769  , m_pFileCreateFunc(in_pCreateFile) // Legacy
1770  , m_pBankCreateFunc(in_pCreateBank) // Legacy
1774  , m_CodecDescriptor{ in_pCreateFile, in_pCreateBank, nullptr, nullptr }
1775  {
1776  g_pAKPluginList = this;
1777  }
1778 
1780  AkUInt32 in_ulCompanyID, ///< Plugin company ID.
1781  AkUInt32 in_ulPluginID, ///< Plugin ID.
1782  const AkCodecDescriptor &in_Descriptor) ///< Codec descriptor.
1785  , m_ulCompanyID(in_ulCompanyID)
1786  , m_ulPluginID(in_ulPluginID)
1787  , m_pCreateFunc(NULL)
1789  , m_pFileCreateFunc(in_Descriptor.pFileSrcCreateFunc) // Legacy
1790  , m_pBankCreateFunc(in_Descriptor.pBankSrcCreateFunc) // Legacy
1794  , m_CodecDescriptor(in_Descriptor)
1795  {
1796  g_pAKPluginList = this;
1797  }
1798 
1805  AkCreateFileSourceCallback m_pFileCreateFunc; ///< LEGACY: Kept for compatibility with 2019.1. Unused in 2019.2 and up.
1806  AkCreateBankSourceCallback m_pBankCreateFunc; ///< LEGACY: Kept for compatibility with 2019.1. Unused in 2019.2 and up.
1809 
1810  // 2019.2 added parameters
1813  };
1814 }
1815 
1816 #define AK_IMPLEMENT_PLUGIN_FACTORY(_pluginName_, _plugintype_, _companyid_, _pluginid_) \
1817  AK::IAkPlugin* Create##_pluginName_(AK::IAkPluginMemAlloc * in_pAllocator); \
1818  AK::IAkPluginParam * Create##_pluginName_##Params(AK::IAkPluginMemAlloc * in_pAllocator); \
1819  AK::PluginRegistration _pluginName_##Registration(_plugintype_, _companyid_, _pluginid_, Create##_pluginName_, Create##_pluginName_##Params);
1820 
1821 #define AK_STATIC_LINK_PLUGIN(_pluginName_) \
1822  extern AK::PluginRegistration _pluginName_##Registration; \
1823  void *_pluginName_##_linkonceonly = (void*)&_pluginName_##Registration;
1824 
1825 #define DEFINE_PLUGIN_REGISTER_HOOK AK_DLLEXPORT AK::PluginRegistration * g_pAKPluginList = NULL;
1826 
1827 #define AK_GET_SINK_TYPE_FROM_DEVICE_KEY(_key) ((AkUInt32)(_key & 0xffffffff))
1828 #define AK_GET_DEVICE_ID_FROM_DEVICE_KEY(_key) ((AkUInt32)(_key >> 32))
1829 
1830 #endif // _IAK_PLUGIN_H_
virtual IAkPluginParam * GetInputParam()=0
virtual AkUInt16 GetNumRefillsInVoice()=0
float AkReal32
32-bit floating point
Definition: AkTypes.h:70
Interface to retrieve contextual information for a mixer.
Definition: IAkPlugin.h:425
MultiPositionType
Definition: AkTypes.h:776
virtual AKRESULT RegisterPlugin(AkPluginType in_eType, AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkCreatePluginCallback in_pCreateFunc, AkCreateParamCallback in_pCreateParamFunc)=0
AkCreateFileSourceCallback m_pFileCreateFunc
LEGACY: Kept for compatibility with 2019.1. Unused in 2019.2 and up.
Definition: IAkPlugin.h:1805
virtual AKRESULT Init(IAkPluginMemAlloc *in_pAllocator, IAkSinkPluginContext *in_pSinkPluginContext, IAkPluginParam *in_pParams, AkAudioFormat &io_rFormat)=0
virtual void Consume(AkAudioBuffer *in_pMainMix, AkAudioBuffer *in_pPassthroughMix, const AkAudioObjects &in_objects, AkRamp in_gain)=0
virtual AKRESULT SetRTPCValue(AkRtpcID in_rtpcID, AkRtpcValue in_value, AkGameObjectID in_gameObjectID=AK_INVALID_GAME_OBJECT, AkTimeMs in_uValueChangeDuration=0, AkCurveInterpolation in_eFadeCurve=AkCurveInterpolation_Linear, bool in_bBypassInternalValueInterpolation=false)=0
AkSpeakerPanningType
Speaker panning type: type of panning logic when object is not 3D spatialized (i.e....
Definition: AkTypes.h:787
Software plug-in interface for sink (audio end point) which supports 3D audio features.
Definition: IAkPlugin.h:1190
virtual AkUniqueID GetAudioNodeID() const =0
AkInt32 AkTimeMs
Time in ms.
Definition: AkTypes.h:66
Audiokinetic namespace.
virtual ~IAkPluginParam()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:605
virtual AKRESULT TimeSkip(AkUInt32 in_uFrames)=0
virtual void * GetCookie() const =0
virtual AkPriority ComputePriorityWithDistance(AkReal32 in_fDistance) const =0
bool bIsDeviceEffect
Plug-in can process final mixes and objects right before sending them to the audio device for output....
Definition: IAkPlugin.h:79
AkPluginServiceType
Definition: IAkPlugin.h:1327
virtual bool IsStarved()=0
virtual IAkGlobalPluginContext * GlobalContext() const =0
AK_DLLEXPORT AK::PluginRegistration * g_pAKPluginList
Definition: IAkPlugin.h:89
virtual ~IAkGlobalPluginContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:1345
virtual AKRESULT Term(IAkPluginMemAlloc *in_pAllocator)=0
Software effect plug-in interface (see Creating Sound Engine Effect Plug-ins).
Definition: IAkPlugin.h:741
virtual AKRESULT PostMonitorData(void *in_pData, AkUInt32 in_uDataSize)=0
virtual AKRESULT Init(IAkPluginMemAlloc *in_pAllocator, IAkEffectPluginContext *in_pEffectPluginContext, IAkPluginParam *in_pParams, AkAudioFormat &io_rFormat)=0
#define AK_DLLEXPORT
Wwise sound engine source plug-in interface (see Creating Sound Engine Source Plug-ins).
Definition: IAkPlugin.h:1218
virtual AkReal32 GetSpread(AkUInt32 in_uIndex)=0
virtual AkUInt16 GetNumLoops() const =0
IAkSoftwareCodec *(* AkCreateFileSourceCallback)(void *in_pCtx)
Registered file source creation function prototype.
Definition: AkTypes.h:744
virtual void EnableMetering(AkMeteringFlags in_eFlags)=0
AkUInt32 AkRtpcID
Real time parameter control ID.
Definition: AkTypes.h:83
virtual AKRESULT IsDataNeeded(AkUInt32 &out_uNumFramesNeeded)=0
virtual ~IAkSinkPluginContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:1057
virtual IAkMixerPluginContext * GetMixerCtx()=0
virtual bool SupportMediaRelocation() const
Definition: IAkPlugin.h:712
AkCreateParamCallback m_pCreateParamFunc
Definition: IAkPlugin.h:1804
virtual AKRESULT SetParam(AkPluginParamID in_paramID, const void *in_pValue, AkUInt32 in_uParamSize)=0
virtual AKRESULT Compute3DPositioning(const AkTransform &in_emitter, const AkTransform &in_listener, AkReal32 in_fCenterPerc, AkReal32 in_fSpread, AkReal32 in_fFocus, AkChannelConfig in_inputConfig, AkChannelMask in_uInputChanSel, AkChannelConfig in_outputConfig, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
virtual AKRESULT StopMIDIOnEventSync(AkUniqueID in_eventID=AK_INVALID_UNIQUE_ID, AkGameObjectID in_gameObjectID=AK_INVALID_GAME_OBJECT, AkPlayingID in_playingID=AK_INVALID_PLAYING_ID)=0
virtual void MixNinNChannels(AkAudioBuffer *in_pInputBuffer, AkAudioBuffer *in_pMixBuffer, AkReal32 in_fPrevGain, AkReal32 in_fNextGain, AK::SpeakerVolumes::ConstMatrixPtr in_mxPrevVolumes, AK::SpeakerVolumes::ConstMatrixPtr in_mxNextVolumes)=0
N to N channels mix.
AkUInt64 AkGameObjectID
Game object ID.
Definition: AkTypes.h:70
bool bCanRunOnObjectConfig
Plug-in can run on bus with Audio Object configuration. Effect plug-ins are instantiated once per Aud...
Definition: IAkPlugin.h:80
virtual AkUInt32 GetSampleRate() const =0
virtual void GetPannerPosition(AkVector &out_position)=0
virtual AKRESULT SendPluginCustomGameData(AkUniqueID in_busID, AkGameObjectID in_busObjectID, AkPluginType in_eType, AkUInt32 in_uCompanyID, AkUInt32 in_uPluginID, const void *in_pData, AkUInt32 in_uSizeInBytes)=0
bool bUsesGainAttribute
Plug-in knows how to process objects separately from the cumulativeGain of the object (or the process...
Definition: IAkPlugin.h:81
AKRESULT
Standard function call result.
Definition: AkTypes.h:132
AKRESULT(* AkGetDeviceListCallback)(AkUInt32 &io_maxNumDevices, AkDeviceDescription *out_deviceDescriptions)
Registered plugin device enumeration function prototype, used for providing lists of devices by plug-...
Definition: IAkPlugin.h:1316
virtual IAkVoicePluginInfo * GetVoiceInfo()=0
void(* AkGlobalCallbackFunc)(AK::IAkGlobalPluginContext *in_pContext, AkGlobalCallbackLocation in_eLocation, void *in_pCookie)
Definition: AkCallback.h:369
uint8_t AkUInt8
Unsigned 8-bit integer.
Definition: AkTypes.h:57
bool bIsInPlace
Buffer usage (in-place or not). If true, and the plug-in is an insert effect, it should implement IAk...
Definition: IAkPlugin.h:75
virtual AkUInt32 GetIDFromString(const char *in_pszString) const =0
AkSinkPluginType
Definition: IAkPlugin.h:1103
virtual AKRESULT ComputeWeightedAmbisonicsDecodingFromSampledSphere(const AkVector in_samples[], AkUInt32 in_uNumSamples, AkChannelConfig in_cfgAmbisonics, AK::SpeakerVolumes::MatrixPtr out_mxVolume)=0
AkCreatePluginCallback m_pCreateFunc
Definition: IAkPlugin.h:1803
Common interface for plug-in services accessed through the global plug-in context.
Definition: IAkPlugin.h:1334
virtual ~IAkAudioDeviceEffectPlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:873
Interface for the "Mixer" plug-in service, to handle mixing together of signals, or applying simple t...
Definition: IAkPlugin.h:1637
virtual ~IAk3DAudioSinkPlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:1193
virtual AkPriority GetPriority() const =0
virtual ~IAkGameObjectPluginInfo()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:103
virtual ~IAkPluginContextBase()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:227
AkUInt32 AkChannelMask
Channel mask (similar to WAVE_FORMAT_EXTENSIBLE). Bit values are defined in AkSpeakerConfig....
Definition: AkTypes.h:90
PluginRegistration(AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkCreateFileSourceCallback in_pCreateFile, AkCreateBankSourceCallback in_pCreateBank)
Definition: IAkPlugin.h:1758
virtual void MixChannel(AkReal32 *AK_RESTRICT in_pInBuffer, AkReal32 *AK_RESTRICT in_pOutBuffer, AkReal32 in_fPrevGain, AkReal32 in_fNextGain, AkUInt16 in_uNumFrames)=0
Single channel mix.
virtual AKRESULT ComputePlanarVBAPGains(AkReal32 in_fAngle, AkChannelConfig in_outputConfig, AkReal32 in_fCenterPerc, AK::SpeakerVolumes::VectorPtr out_vVolumes)=0
virtual void GetPluginMedia(AkUInt32 in_dataIndex, AkUInt8 *&out_rpData, AkUInt32 &out_rDataSize)=0
virtual void GetSpatializedVolumes(AK::SpeakerVolumes::MatrixPtr out_mxPrevVolumes, AK::SpeakerVolumes::MatrixPtr out_mxNextVolumes)=0
virtual void Execute(AkAudioBuffer *io_pBuffer)=0
PluginRegistration(AkPluginType in_eType, AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkCreatePluginCallback in_pCreateFunc, AkCreateParamCallback in_pCreateParamFunc, AkGlobalCallbackFunc in_pRegisterCallback=NULL, void *in_pRegisterCallbackCookie=NULL)
Definition: IAkPlugin.h:1707
virtual IAkProcessorFeatures * GetProcessorFeatures()=0
Return an interface to query processor specific features.
virtual void GetOutputObjects(AkAudioObjects &io_objects)=0
#define NULL
Definition: AkTypes.h:47
PluginRegistration(AkPluginType in_eType, AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkCreatePluginCallback in_pCreateFunc, AkCreateParamCallback in_pCreateParamFunc, AkGetDeviceListCallback in_pGetDeviceListFunc, AkGlobalCallbackFunc in_pRegisterCallback=NULL, void *in_pRegisterCallbackCookie=NULL)
Definition: IAkPlugin.h:1732
virtual ~IAkMixerInputContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:900
@ AK_Success
The operation was successful.
Definition: AkTypes.h:134
virtual AkUInt16 GetMaxBufferLength() const =0
@ AkSinkPluginType_Sink
Definition: IAkPlugin.h:1104
bool bCanChangeRate
True for effects whose sample throughput is different between input and output. Effects that can chan...
Definition: IAkPlugin.h:76
virtual void Mix1inNChannels(AkReal32 *AK_RESTRICT in_pInChannel, AkAudioBuffer *in_pMixBuffer, AkReal32 in_fPrevGain, AkReal32 in_fNextGain, AK::SpeakerVolumes::ConstVectorPtr in_vPrevVolumes, AK::SpeakerVolumes::ConstVectorPtr in_vNextVolumes)=0
1 to N channels mix
Emitter-listener pair: Positioning data pertaining to a single pair of emitter and listener.
Definition: AkTypes.h:499
PluginRegistration(AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID)
Definition: IAkPlugin.h:1699
virtual bool HasListenerRelativeRouting()=0
AkPluginInfo()
Constructor for default values.
Definition: IAkPlugin.h:61
virtual IAkGameObjectPluginInfo * GetGameObjectInfo()=0
virtual bool GetMaxAttenuationDistance(AkReal32 &out_fMaxAttenuationDistance)=0
virtual AKRESULT GetGameObjectPosition(AkUInt32 in_uIndex, AkSoundPosition &out_position) const =0
virtual AKRESULT GetPluginInfo(AkPluginInfo &out_rPluginInfo)=0
Software interface for sink (audio endpoint) plugins.
Definition: IAkPlugin.h:1166
virtual void SetUserData(void *in_pUserData)=0
virtual bool IsSendModeEffect() const =0
virtual IAkVoicePluginInfo * GetVoiceInfo()=0
virtual void OnFrameEnd()=0
virtual AKRESULT PostMonitorMessage(const char *in_pszError, AK::Monitor::ErrorLevel in_eErrorLevel)=0
Software effect plug-in interface for out-of-place processing (see Creating Sound Engine Effect Plug-...
Definition: IAkPlugin.h:785
AkReal32 * VectorPtr
Volume vector. Access each element with the standard bracket [] operator.
Definition: AkSpeakerVolumes.h:49
Ak3DPositionType
3D position type: defines what acts as the emitter position for computing spatialization against the ...
Definition: AkTypes.h:796
virtual ~IAkMixerPluginContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:428
virtual AkSinkPluginType GetSinkPluginType() const override final
Definition: IAkPlugin.h:1213
@ PluginServiceType_MAX
Definition: IAkPlugin.h:1329
virtual Ak3DSpatializationMode Get3DSpatializationMode()=0
virtual AkPlayingID GetPlayingID() const =0
Retrieve the Playing ID of the event corresponding to this voice (if applicable).
AkUInt32 AkUniqueID
Unique 32-bit ID.
Definition: AkTypes.h:62
virtual AkReal32 GetFocus(AkUInt32 in_uIndex)=0
Configured audio settings.
Definition: AkTypes.h:213
virtual AKRESULT SignalAudioThread()=0
AkUInt32 AkPluginID
Source or effect plug-in ID.
Definition: AkTypes.h:73
virtual AkReal32 GetEnvelope() const
Definition: IAkPlugin.h:1248
virtual void Execute(const AkAudioObjects &io_objects)=0
virtual AKRESULT Init(IAkPluginMemAlloc *in_pAllocator, const void *in_pParamsBlock, AkUInt32 in_uBlockSize)=0
AkCodecDescriptor m_CodecDescriptor
Definition: IAkPlugin.h:1812
virtual bool CanPostMonitorData()=0
AkUInt32 AkAcousticTextureID
Acoustic Texture ID.
Definition: AkTypes.h:92
virtual AkSpeakerPanningType GetSpeakerPanningType()=0
virtual void Execute(AkAudioBuffer *in_pBuffer, AkUInt32 in_uInOffset, AkAudioBuffer *out_pBuffer)=0
virtual AkMIDIEvent GetMidiEvent() const =0
virtual AkUInt32 GetNum3DPositions()=0
AkPluginType eType
Plug-in type.
Definition: IAkPlugin.h:73
virtual ~IAkVoicePluginInfo()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:204
Spherical coordinates.
Definition: AkTypes.h:493
virtual void Consume(AkAudioBuffer *in_pInputBuffer, AkRamp in_gain)=0
virtual AkUInt32 GetBusType()=0
virtual AkConnectionType GetConnectionType()=0
AkMeteringFlags
Metering flags. Used for specifying bus metering, through AK::SoundEngine::RegisterBusVolumeCallback(...
Definition: AkTypes.h:830
virtual AKRESULT ComputeSphericalVBAPGains(void *in_pPannerData, AkReal32 in_fAzimuth, AkReal32 in_fElevation, AkUInt32 in_uNumChannels, AK::SpeakerVolumes::VectorPtr out_vVolumes)=0
virtual AKRESULT InitSphericalVBAP(AK::IAkPluginMemAlloc *in_pAllocator, const AkSphericalCoord *in_SphericalPositions, const AkUInt32 in_NbPoints, void *&out_pPannerData)=0
const AkReal32 * ConstMatrixPtr
Constant volume matrix. Access each input channel vector with AK::SpeakerVolumes::Matrix::GetChannel(...
Definition: AkSpeakerVolumes.h:52
virtual IAkPluginParam * Clone(IAkPluginMemAlloc *in_pAllocator)=0
AkGetDeviceListCallback m_pGetDeviceListFunc
Definition: IAkPlugin.h:1811
Volume ramp specified by end points "previous" and "next".
Definition: AkTypes.h:635
AkInt8 AkPriority
Priority.
Definition: AkTypes.h:77
Voice-specific information available to plug-ins.
Definition: IAkPlugin.h:201
virtual AkSinkPluginType GetSinkPluginType() const =0
virtual const AkAcousticTexture * GetAcousticTexture(AkAcousticTextureID in_AcousticTextureID)=0
void(* AkCallbackFunc)(AkCallbackType in_eType, AkCallbackInfo *in_pCallbackInfo)
Definition: AkCallback.h:267
virtual AKRESULT ComputeSphericalCoordinates(const AkEmitterListenerPair &in_pair, AkReal32 &out_fAzimuth, AkReal32 &out_fElevation) const =0
virtual AKRESULT GetOutputID(AkUInt32 &out_uOutputID, AkPluginID &out_uDevicePlugin) const =0
AkUInt32 m_ulPluginID
Definition: IAkPlugin.h:1802
virtual AKRESULT Term(IAkPluginMemAlloc *in_pAllocator)=0
virtual AKRESULT TimeSkip(AkUInt32 &)
Definition: IAkPlugin.h:1286
PluginRegistration(AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, const AkCodecDescriptor &in_Descriptor)
Definition: IAkPlugin.h:1779
virtual void Execute(AkAudioBuffer *io_pBuffer)=0
void * m_pRegisterCallbackCookie
Definition: IAkPlugin.h:1808
AkCurveInterpolation
Curve interpolation types.
Definition: AkTypes.h:602
virtual ~IAkSourcePluginContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:400
#define AK_CALLBACK(_type, _name)
virtual void * GetUserData()=0
virtual bool GetListeners(AkGameObjectID *out_aListenerIDs, AkUInt32 &io_uSize) const =0
virtual bool IsRenderingOffline() const =0
Ak3DSpatializationMode
3D spatialization mode.
Definition: AkTypes.h:812
virtual AKRESULT Compute3DPositioning(AkReal32 in_fAngle, AkReal32 in_fElevation, AkReal32 in_fSpread, AkReal32 in_fFocus, AkChannelConfig in_inputConfig, AkChannelMask in_uInputChanSel, AkChannelConfig in_outputConfig, AkReal32 in_fCenterPerc, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
@ AK_NotImplemented
This feature is not implemented.
Definition: AkTypes.h:133
virtual ~IAkPluginService()
Definition: IAkPlugin.h:1336
uint16_t AkUInt16
Unsigned 16-bit integer.
Definition: AkTypes.h:58
virtual AKRESULT GetParentChannelConfig(AkChannelConfig &out_channelConfig) const =0
virtual IAkPluginService * GetPluginService(AkPluginServiceType in_pluginService) const =0
virtual AKRESULT SetParamsBlock(const void *in_pParamsBlock, AkUInt32 in_uBlockSize)=0
Software effect plug-in interface for in-place processing (see Creating Sound Engine Effect Plug-ins)...
Definition: IAkPlugin.h:761
virtual void Execute(const AkAudioObjects &in_objects, const AkAudioObjects &out_objects)=0
static const AkUniqueID AK_INVALID_UNIQUE_ID
Invalid unique 32-bit ID.
Definition: AkTypes.h:102
virtual AKRESULT Init(IAkPluginMemAlloc *in_pAllocator, IAkAudioDeviceEffectPluginContext *in_pEffectPluginContext, IAkPluginParam *in_pParams, const AkAudioFormat &in_rFormat, const Ak3DAudioSinkCapabilities &in_3dCapabilities)=0
virtual AkReal32 GetGameObjectScaling() const =0
virtual void ResetStarved()=0
Reset the "starvation" flag after IsStarved() returned true.
virtual AKRESULT RelocateMedia(AkUInt8 *, AkUInt8 *)
Definition: IAkPlugin.h:729
@ AkCurveInterpolation_Linear
Linear (Default)
Definition: AkTypes.h:609
@ PluginServiceType_Mixer
Definition: IAkPlugin.h:1328
virtual IAkVoicePluginInfo * GetVoiceInfo()=0
static const AkPlayingID AK_INVALID_PLAYING_ID
Invalid playing ID.
Definition: AkTypes.h:104
virtual AKRESULT ComputeSpeakerVolumesDirect(AkChannelConfig in_inputConfig, AkChannelConfig in_outputConfig, AkReal32 in_fCenterPerc, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
virtual AkReal32 GetDownstreamGain()=0
bool bReserved
Legacy bIsAsynchronous plug-in flag, now unused. Preserved for plug-in backward compatibility....
Definition: IAkPlugin.h:77
Positioning data of 3D audio objects.
Definition: AkCommonDefs.h:294
A collection of audio objects. Encapsulates the audio data and metadata of each audio object in separ...
Definition: AkCommonDefs.h:635
virtual AKRESULT TimeSkip(AkUInt32 &io_uFrames)=0
virtual IAkGameObjectPluginInfo * GetGameObjectInfo()=0
virtual AKRESULT ComputePositioning(const AkPositioningData &in_posData, AkChannelConfig in_inputConfig, AkChannelConfig in_outputConfig, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
virtual AKRESULT UnregisterGlobalCallback(AkGlobalCallbackFunc in_pCallback, AkUInt32 in_eLocation=AkGlobalCallbackLocation_BeginRender)=0
virtual void ApplyGain(AkAudioBuffer *in_pInputBuffer, AkAudioBuffer *in_pOutputBuffer, AkRamp in_gain, bool in_convertToInt16) const =0
AkUInt32 uBuildVersion
Plug-in build version, must match the AK_WWISESDK_VERSION_COMBINED macro from AkWwiseSDKVersion....
Definition: IAkPlugin.h:74
AkReal32 * MatrixPtr
Volume matrix. Access each input channel vector with AK::SpeakerVolumes::Matrix::GetChannel().
Definition: AkSpeakerVolumes.h:50
virtual AKRESULT Reset()=0
AK::IAkPluginParam *(* AkCreateParamCallback)(AK::IAkPluginMemAlloc *in_pAllocator)
Registered plugin parameter node creation function prototype.
Definition: IAkPlugin.h:1314
virtual void Get3DAudioCapabilities(Ak3DAudioSinkCapabilities &out_rCapabilities)=0
Returns the capabilities of the sink's 3D audio system.
virtual ~IAkEffectPlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:744
virtual ~IAkSinkPlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:1169
virtual AKRESULT GetAudioSettings(AkAudioSettings &out_audioSettings) const =0
virtual IAkPlatformContext * GetPlatformContext() const =0
virtual AKRESULT StopLooping()
Definition: IAkPlugin.h:1262
virtual AkReal32 GetCenterPerc()=0
PluginRegistration * pNext
Definition: IAkPlugin.h:1799
static const AkGameObjectID AK_INVALID_GAME_OBJECT
Invalid game object (may also mean all game objects)
Definition: AkTypes.h:101
virtual AkPlayingID PostEventSync(AkUniqueID in_eventID, AkGameObjectID in_gameObjectID, AkUInt32 in_uFlags=0, AkCallbackFunc in_pfnCallback=NULL, void *in_pCookie=NULL, AkUInt32 in_cExternals=0, AkExternalSourceInfo *in_pExternalSources=NULL, AkPlayingID in_PlayingID=AK_INVALID_PLAYING_ID)=0
virtual AKRESULT ComputePositioning(const AkPositioningData &in_posData, AkChannelConfig in_inputConfig, AkChannelConfig in_outputConfig, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
virtual void ApplyGainAndInterleave(AkAudioBuffer *in_pInputBuffer, AkAudioBuffer *in_pOutputBuffer, AkRamp in_gain, bool in_convertToInt16) const =0
virtual AKRESULT Get3DPosition(AkUInt32 in_uIndex, AkEmitterListenerPair &out_soundPosition)=0
virtual ~IAkSourcePlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:1221
@ AkPluginTypeCodec
Compressor/decompressor plug-in (allows support for custom audio file types).
Definition: AkTypes.h:846
uint32_t AkUInt32
Unsigned 32-bit integer.
Definition: AkTypes.h:59
virtual AkSinkPluginType GetSinkPluginType() const override final
Definition: IAkPlugin.h:1185
AkInt16 AkPluginParamID
Source or effect plug-in parameter ID.
Definition: AkTypes.h:76
virtual ~IAkPlugin()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:676
virtual AKRESULT GetEmitterListenerPair(AkUInt32 in_uIndex, AkEmitterListenerPair &out_emitterListenerPair) const =0
Definition: AkMidiTypes.h:238
Game object information available to plugins.
Definition: IAkPlugin.h:100
virtual AK::IAkPluginMemAlloc * GetAllocator()=0
Get the default allocator for plugins. This is useful for performing global initialization tasks shar...
virtual AKRESULT CreateOutputObjects(AkChannelConfig in_channelConfig, AkAudioObjects &io_objects)=0
virtual AKRESULT Init(IAkPluginMemAlloc *in_pAllocator, IAkSourcePluginContext *in_pSourcePluginContext, IAkPluginParam *in_pParams, AkAudioFormat &io_rFormat)=0
3D vector.
Definition: AkTypes.h:311
virtual AKRESULT Seek(AkUInt32)
Definition: IAkPlugin.h:1276
virtual ~IAkEffectPluginContext()
Virtual destructor on interface to avoid warnings.
Definition: IAkPlugin.h:342
virtual AkGameObjectID GetGameObjectID() const =0
Get the ID of the game object.
AkReal32 AkRtpcValue
Real time parameter control value.
Definition: AkTypes.h:84
@ AkSinkPluginType_3DAudioSink
Definition: IAkPlugin.h:1105
virtual const AkPlatformInitSettings * GetPlatformInitSettings() const =0
AkGlobalCallbackFunc m_pRegisterCallback
Definition: IAkPlugin.h:1807
virtual bool IsPrimary()=0
virtual AKRESULT ComputeSpeakerVolumesPanner(AkSpeakerPanningType in_ePannerType, const AkVector &in_position, AkReal32 in_fCenterPct, AkChannelConfig in_inputConfig, AkChannelConfig in_outputConfig, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
Listener information.
Definition: AkTypes.h:588
virtual AkUInt32 GetBufferTick() const =0
virtual const AkInitSettings * GetInitSettings() const =0
virtual AKRESULT PostMonitorMessage(const char *in_pszError, AK::Monitor::ErrorLevel in_eErrorLevel)=0
virtual SoundEngine::MultiPositionType GetGameObjectMultiPositionType() const =0
bool bCanProcessObjects
Plug-in can process audio objects. They must implement IAkInPlaceObjectPlugin or IAkOutOfPlaceObjectP...
Definition: IAkPlugin.h:78
virtual void Execute(AkAudioBuffer *io_pMainMix, AkAudioBuffer *io_pPassthroughMix, const AkAudioObjects &io_objects, AkRamp &io_gain)=0
static const AkPluginParamID ALL_PLUGIN_DATA_ID
Definition: IAkPlugin.h:666
virtual AkPlayingID PostMIDIOnEventSync(AkUniqueID in_eventID, AkGameObjectID in_gameObjectID, AkMIDIPost *in_pPosts, AkUInt16 in_uNumPosts, bool in_bAbsoluteOffsets=false, AkUInt32 in_uFlags=0, AkCallbackFunc in_pfnCallback=NULL, void *in_pCookie=NULL, AkPlayingID in_playingID=AK_INVALID_PLAYING_ID)=0
AkPluginType m_eType
Definition: IAkPlugin.h:1800
ErrorLevel
ErrorLevel.
Definition: AkMonitorError.h:45
virtual AKRESULT TermSphericalVBAP(AK::IAkPluginMemAlloc *in_pAllocator, void *in_pPannerData)=0
virtual AkUInt32 GetNumEmitterListenerPairs() const =0
virtual ~IAkPluginServiceMixer()
Definition: IAkPlugin.h:1639
@ AkPluginTypeNone
Unknown/invalid plug-in type.
Definition: AkTypes.h:845
AK::IAkPlugin *(* AkCreatePluginCallback)(AK::IAkPluginMemAlloc *in_pAllocator)
Registered plugin creation function prototype.
Definition: IAkPlugin.h:1312
Defines the parameters of an audio buffer format.
Definition: AkCommonDefs.h:63
IAkSoftwareCodec *(* AkCreateBankSourceCallback)(void *in_pCtx)
Registered bank source node creation function prototype.
Definition: AkTypes.h:746
virtual Ak3DPositionType Get3DPositionType()=0
AkConnectionType
Nature of the connection binding an input to a bus.
Definition: AkTypes.h:302
Position and orientation of game objects.
Definition: AkTypes.h:346
virtual AKRESULT RegisterCodec(AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkCreateFileSourceCallback in_pFileCreateFunc, AkCreateBankSourceCallback in_pBankCreateFunc)=0
AkUInt32 m_ulCompanyID
Definition: IAkPlugin.h:1801
virtual void ComputeAmbisonicsEncoding(AkReal32 in_fAzimuth, AkReal32 in_fElevation, AkChannelConfig in_cfgAmbisonics, AK::SpeakerVolumes::VectorPtr out_vVolumes)=0
AkPluginType
Definition: AkTypes.h:844
AkUInt32 AkPlayingID
Playing ID.
Definition: AkTypes.h:65
virtual AkReal32 GetDuration() const =0
virtual AKRESULT GetSpeakerAngles(AkReal32 *io_pfSpeakerAngles, AkUInt32 &io_uNumAngles, AkReal32 &out_fHeightAngle)=0
@ AkGlobalCallbackLocation_BeginRender
Start of frame rendering, after having processed game messages.
Definition: AkCallback.h:343
#define AK_RESTRICT
Refers to the __restrict compilation flag available on some platforms.
Definition: AkTypes.h:43
const AkReal32 * ConstVectorPtr
Constant volume vector. Access each element with the standard bracket [] operator.
Definition: AkSpeakerVolumes.h:51
virtual AKRESULT RegisterGlobalCallback(AkPluginType in_eType, AkUInt32 in_ulCompanyID, AkUInt32 in_ulPluginID, AkGlobalCallbackFunc in_pCallback, AkUInt32 in_eLocation=AkGlobalCallbackLocation_BeginRender, void *in_pCookie=NULL)=0
virtual void GetPluginCustomGameData(void *&out_rpData, AkUInt32 &out_rDataSize)=0
Interface to retrieve contextual information available to all types of plugins.
Definition: IAkPlugin.h:224
virtual AKRESULT ComputePositioning(const AkPositioningData &in_posData, AkChannelConfig in_inputConfig, AkChannelConfig in_outputConfig, AK::SpeakerVolumes::MatrixPtr out_mxVolumes)=0
AkCreateBankSourceCallback m_pBankCreateFunc
LEGACY: Kept for compatibility with 2019.1. Unused in 2019.2 and up.
Definition: IAkPlugin.h:1806
virtual AKRESULT GetListenerData(AkGameObjectID in_uListener, AkListener &out_listener) const =0
virtual AkUInt32 GetNumGameObjectPositions() const =0
virtual IAkStreamMgr * GetStreamMgr() const =0
Retrieve the streaming manager access interface.

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Register your project and we'll help you get started with no strings attached!

Get started with Wwise