Table of Contents

include/AK/SoundEngine/Common/AkSoundEngine.h

Go to the documentation of this file.
00001 /*******************************************************************************
00002 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
00003 released in source code form as part of the SDK installer package.
00004 
00005 Commercial License Usage
00006 
00007 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
00008 may use this file in accordance with the end user license agreement provided 
00009 with the software or, alternatively, in accordance with the terms contained in a
00010 written agreement between you and Audiokinetic Inc.
00011 
00012 Apache License Usage
00013 
00014 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
00015 "Apache License"); you may not use this file except in compliance with the 
00016 Apache License. You may obtain a copy of the Apache License at 
00017 http://www.apache.org/licenses/LICENSE-2.0.
00018 
00019 Unless required by applicable law or agreed to in writing, software distributed
00020 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
00021 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
00022 the specific language governing permissions and limitations under the License.
00023 
00024   Version: <VERSION>  Build: <BUILDNUMBER>
00025   Copyright (c) <COPYRIGHTYEAR> Audiokinetic Inc.
00026 *******************************************************************************/
00027 
00028 // AkSoundEngine.h
00029 
00030 /// \file 
00031 /// The main sound engine interface.
00032 
00033 
00034 #ifndef _AK_SOUNDENGINE_H_
00035 #define _AK_SOUNDENGINE_H_
00036 
00037 #include <AK/SoundEngine/Common/AkSoundEngineExport.h>
00038 #include <AK/SoundEngine/Common/AkTypes.h>
00039 #include <AK/SoundEngine/Common/IAkPlugin.h>
00040 #include <AK/SoundEngine/Common/AkCallback.h>
00041 
00042 #ifdef AK_WIN
00043 #include <AK/SoundEngine/Platforms/Windows/AkWinSoundEngine.h>
00044 #include <AK/SoundEngine/Platforms/Windows/AkPlatformContext.h>
00045 
00046 #elif defined (AK_MAC_OS_X)
00047 #include <AK/SoundEngine/Platforms/Mac/AkMacSoundEngine.h>
00048 #include <AK/SoundEngine/Platforms/Mac/AkPlatformContext.h>
00049 
00050 #elif defined (AK_IOS)
00051 #include <AK/SoundEngine/Platforms/iOS/AkiOSSoundEngine.h>
00052 #include <AK/SoundEngine/Platforms/iOS/AkPlatformContext.h>
00053 
00054 #elif defined (AK_XBOXONE)
00055 #include <AK/SoundEngine/Platforms/XboxOne/AkXboxOneSoundEngine.h>
00056 #include <AK/SoundEngine/Platforms/XboxOne/AkPlatformContext.h>
00057 
00058 #elif defined( AK_LUMIN )
00059 #include <AK/SoundEngine/Platforms/Lumin/AkLuminSoundEngine.h>
00060 #include <AK/SoundEngine/Platforms/Lumin/AkPlatformContext.h>
00061 
00062 #elif defined( AK_ANDROID )
00063 #include <AK/SoundEngine/Platforms/Android/AkAndroidSoundEngine.h>
00064 #include <AK/SoundEngine/Platforms/Android/AkPlatformContext.h>
00065 
00066 #elif defined (AK_PS4)
00067 #include <AK/SoundEngine/Platforms/PS4/AkPS4SoundEngine.h>
00068 #include <AK/SoundEngine/Platforms/PS4/AkPlatformContext.h>
00069 
00070 #elif defined( AK_GGP )
00071 #include <AK/SoundEngine/Platforms/GGP/AkGGPSoundEngine.h>
00072 #include <AK/SoundEngine/Platforms/GGP/AkPlatformContext.h>
00073 
00074 #elif defined( AK_LINUX_DESKTOP )
00075 #include <AK/SoundEngine/Platforms/Linux/AkLinuxSoundEngine.h>
00076 #include <AK/SoundEngine/Platforms/Linux/AkPlatformContext.h>
00077 
00078 #elif defined( AK_EMSCRIPTEN )
00079 #include <AK/SoundEngine/Platforms/Emscripten/AkEmscriptenSoundEngine.h>
00080 #include <AK/SoundEngine/Platforms/Emscripten/AkPlatformContext.h>
00081 
00082 #elif defined( AK_QNX  )
00083 #include <AK/SoundEngine/Platforms/QNX/AkQNXSoundEngine.h>
00084 #include <AK/SoundEngine/Platforms/QNX/AkPlatformContext.h>
00085 
00086 #elif defined( AK_NX )
00087 #include <AK/SoundEngine/Platforms/NX/AkNXSoundEngine.h>
00088 #include <AK/SoundEngine/Platforms/NX/AkPlatformContext.h>
00089 
00090 #else
00091 #error AkSoundEngine.h: Undefined platform
00092 #endif
00093 
00094 #ifndef AK_ASSERT_HOOK
00095     /// Function called on assert handling, optional
00096     /// \sa 
00097     /// - AkInitSettings
00098     AK_CALLBACK( void, AkAssertHook)( 
00099         const char * in_pszExpression,  ///< Expression
00100         const char * in_pszFileName,    ///< File Name
00101         int in_lineNumber               ///< Line Number
00102         );
00103     #define AK_ASSERT_HOOK
00104 #endif
00105 
00106 /// Callback function prototype for User Music notifications
00107 /// It is useful for reacting to user music playback.
00108 ///
00109 /// \sa
00110 /// - \ref AkGlobalCallbackFunc
00111 /// - \ref AkPlatformInitSettings
00112 /// - \ref background_music_and_dvr
00113 ///
00114 typedef AKRESULT ( * AkBackgroundMusicChangeCallbackFunc )(
00115     bool in_bBackgroundMusicMuted,  ///< Flag indicating whether the busses tagged as "background music" in the project are muted or not.
00116     void* in_pCookie ///< User-provided data, e.g. a user structure.
00117     );
00118 
00119 /// Platform-independent initialization settings of output devices.
00120 struct AkOutputSettings
00121 {
00122     AkOutputSettings() :
00123         audioDeviceShareset(AK_INVALID_UNIQUE_ID),      
00124         idDevice(0),        
00125         ePanningRule(AkPanningRule_Speakers),
00126         channelConfig(){};
00127 
00128     AkOutputSettings(const char* in_szDeviceShareSet, AkUniqueID in_idDevice = AK_INVALID_UNIQUE_ID, AkChannelConfig in_channelConfig = AkChannelConfig(), AkPanningRule in_ePanning = AkPanningRule_Speakers);     
00129 
00130 #ifdef AK_SUPPORT_WCHAR
00131     AkOutputSettings(const wchar_t* in_szDeviceShareSet, AkUniqueID in_idDevice = AK_INVALID_UNIQUE_ID, AkChannelConfig in_channelConfig = AkChannelConfig(), AkPanningRule in_ePanning = AkPanningRule_Speakers);
00132 #endif
00133 
00134     AkUniqueID      audioDeviceShareset;    ///< Unique ID of a custom audio device to be used. Custom audio devices are defined in the Audio Device Shareset section of the Wwise project.
00135                                             ///< If you want to output normally through the default system, leave this field to its default value (AK_INVALID_UNIQUE_ID).
00136                                             ///< Typical usage: AkInitSettings.eOutputSettings.audioDeviceShareset = AK::SoundEngine::GetIDFromString("InsertYourAudioDeviceSharesetNameHere");
00137                                             /// \sa <tt>\ref AK::SoundEngine::GetIDFromString()</tt>
00138                                             /// \sa \ref soundengine_plugins_audiodevices
00139                                             /// \sa \ref integrating_secondary_outputs
00140                                             /// \sa \ref default_audio_devices
00141 
00142     AkUInt32        idDevice;               ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
00143                                             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
00144                                             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.                                         
00145                                             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.  Leave to 0 for the default Windows device as seen in Audio Properties.
00146                                             ///< - All other outputs: use 0 to select the default for the selected audio device type (shareset) 
00147 
00148     AkPanningRule   ePanningRule;           ///< Rule for 3D panning of signals routed to a stereo bus. In AkPanningRule_Speakers mode, the angle of the front loudspeakers 
00149                                             ///< (uSpeakerAngles[0]) is used. In AkPanningRule_Headphones mode, the speaker angles are superseded with constant power panning
00150                                             ///< between two virtual microphones spaced 180 degrees apart.
00151 
00152     AkChannelConfig channelConfig;          ///< Channel configuration for this output. Call AkChannelConfig::Clear() to let the engine use the default output configuration.  
00153                                             ///< Hardware might not support the selected configuration.
00154 };
00155 
00156 /// Possible values for the floor plane axis used in the Game Object 3D Viewer in Wwise
00157 enum AkFloorPlane
00158 {
00159     AkFloorPlane_XZ = 0,
00160     AkFloorPlane_XY,
00161     AkFloorPlane_YZ,
00162     AkFloorPlane_Default = AkFloorPlane_XZ
00163 };
00164 
00165 /// The execution context for a task.
00166 struct AkTaskContext
00167 {
00168     AkUInt32 uIdxThread;           ///< The current thread index [0, AkTaskSchedulerDesc::uNumSchedulerWorkerThreads[.
00169 };
00170 
00171 /// Task function: process the [in_uIdxBegin,in_uIdxEnd[ range of items in the in_pData array.
00172 typedef void(*AkParallelForFunc)(void* in_pData, AkUInt32 in_uIdxBegin, AkUInt32 in_uIdxEnd, AkTaskContext in_ctx, void* in_pUserData);
00173 
00174 /// Description of the client task scheduler.
00175 struct AkTaskSchedulerDesc
00176 {
00177     /// Execute in_func in parallel over the [in_uIdxBegin,in_uIdxEnd[ range of items in the in_pData array,
00178     /// and wait for the work to finish.
00179     typedef void(*ParallelForFunc)(
00180         void * in_pData,            ///< A pointer to a data array.
00181         AkUInt32 in_uIdxBegin,     ///< The first element of data to process.
00182         AkUInt32 in_uIdxEnd,       ///< The one past the last element of data to process.
00183         AkUInt32 in_uTileSize,     ///< The desired maximum tile size in which to subdivide the data.
00184         AkParallelForFunc in_func, ///< The data processing function.
00185         void * in_pUserData,       ///< User data to be passed into 'func'.
00186         const char * in_szDebugName);    ///< Debug name for the workload.
00187 
00188     ParallelForFunc fcnParallelFor;             ///< ParallelForFunc callback.
00189     AkUInt32        uNumSchedulerWorkerThreads; ///< The number of worker threads in the schduler.
00190 };
00191 
00192 /// Platform-independent initialization settings of the sound engine
00193 /// \sa 
00194 /// - <tt>AK::SoundEngine::Init()</tt>
00195 /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00196 /// - \ref soundengine_integration_init_advanced
00197 /// - \ref soundengine_initialization_advanced_soundengine_using_memory_threshold
00198 struct AkInitSettings
00199 {
00200     AkAssertHook        pfnAssertHook;              ///< External assertion handling function (optional)
00201 
00202     AkUInt32            uMaxNumPaths;               ///< Maximum number of paths for positioning
00203     AkUInt32            uDefaultPoolSize;           ///< Size of the default memory pool, in bytes
00204     AkReal32            fDefaultPoolRatioThreshold; ///< 0.0f to 1.0f value: The percentage of occupied memory where the sound engine should enter in Low memory Mode. \ref soundengine_initialization_advanced_soundengine_using_memory_threshold
00205     AkUInt32            uCommandQueueSize;          ///< Size of the command queue, in bytes
00206     AkMemPoolId         uPrepareEventMemoryPoolID;  ///< Memory pool where data allocated by <tt>AK::SoundEngine::PrepareEvent()</tt> and <tt>AK::SoundEngine::PrepareGameSyncs()</tt> will be done. 
00207     bool                bEnableGameSyncPreparation; ///< Sets to true to enable AK::SoundEngine::PrepareGameSync usage.
00208     AkUInt32            uContinuousPlaybackLookAhead;   ///< Number of quanta ahead when continuous containers should instantiate a new voice before which next sounds should start playing. This look-ahead time allows I/O to occur, and is especially useful to reduce the latency of continuous containers with trigger rate or sample-accurate transitions. 
00209                                                     ///< Default is 1 audio quantum, also known as an audio frame. Its size is equal to AkInitSettings::uNumSamplesPerFrame / AkPlatformInitSettings::uSampleRate. For many platforms the default values - which can be overridden - are respectively 1,024 samples and 48 kHz. This gives a default 21.3 ms for an audio quantum, which is adequate if you have a RAM-based streaming device that completes transfers within 20 ms. With 1 look-ahead quantum, voices spawned by continuous containers are more likely to be ready when they are required to play, thereby improving the overall precision of sound scheduling. If your device completes transfers in 30 ms instead, you might consider increasing this value to 2 because it will grant new voices 2 audio quanta (~43 ms) to fetch data. 
00210 
00211     AkUInt32            uNumSamplesPerFrame;        ///< Number of samples per audio frame (256, 512, 1024, or 2048).
00212 
00213     AkUInt32            uMonitorPoolSize;           ///< Size of the monitoring pool, in bytes. This parameter is not used in Release build.
00214     AkUInt32            uMonitorQueuePoolSize;      ///< Size of the monitoring queue pool, in bytes. This parameter is not used in Release build.
00215     
00216     AkOutputSettings    settingsMainOutput;         ///< Main output device settings.
00217     AkUInt32            uMaxHardwareTimeoutMs;      ///< Amount of time to wait for HW devices to trigger an audio interrupt. If there is no interrupt after that time, the sound engine will revert to  silent mode and continue operating until the HW finally comes back. Default value: 2000 (2 seconds)
00218 
00219     bool                bUseSoundBankMgrThread;     ///< Use a separate thread for loading sound banks. Allows asynchronous operations.
00220     bool                bUseLEngineThread;          ///< Use a separate thread for processing audio. If set to false, audio processing will occur in RenderAudio(). \ref goingfurther_eventmgrthread
00221 
00222     AkBackgroundMusicChangeCallbackFunc BGMCallback; ///< Application-defined audio source change event callback function.
00223     void*               BGMCallbackCookie;          ///< Application-defined user data for the audio source change event callback function.
00224     AkOSChar *          szPluginDLLPath;            ///< When using DLLs for plugins, specify their path. Leave NULL if DLLs are in the same folder as the game executable.
00225 
00226     AkFloorPlane        eFloorPlane;                ///< Floor plane axis for 3D game object viewing.
00227     AkTaskSchedulerDesc taskSchedulerDesc;          ///< The defined client task scheduler that AkSoundEngine will use to schedule internal tasks.
00228 };
00229 
00230 /// Necessary settings for setting externally-loaded sources
00231 struct AkSourceSettings
00232 {
00233     AkUniqueID  sourceID;                           ///< Source ID (available in the SoundBank content files)
00234     AkUInt8*    pMediaMemory;                       ///< Pointer to the data to be set for the source
00235     AkUInt32    uMediaSize;                         ///< Size, in bytes, of the data to be set for the source
00236 };
00237 
00238 /// Return values for GetSourcePlayPositions.
00239 struct AkSourcePosition
00240 {
00241     AkUniqueID  audioNodeID;                        ///< Audio Node ID of playing item
00242     AkUniqueID  mediaID;                            ///< Media ID of playing item. (corresponds to 'ID' attribute of 'File' element in SoundBank metadata file)
00243     AkTimeMs    msTime;                             ///< Position of the source (in ms) associated with that playing item
00244 };
00245 
00246 /// Audiokinetic namespace
00247 namespace AK
00248 {
00249     class IReadBytes;
00250     class IWriteBytes;
00251 
00252     /// Audiokinetic sound engine namespace
00253     /// \remarks The functions in this namespace are thread-safe, unless stated otherwise.
00254     namespace SoundEngine
00255     {
00256         ///////////////////////////////////////////////////////////////////////
00257         /// @name Initialization
00258         //@{
00259 
00260         /// Query whether or not the sound engine has been successfully initialized.
00261         /// \warning This function is not thread-safe. It should not be called at the same time as \c SoundEngine::Init() or \c SoundEngine::Term().
00262         /// \return \c True if the sound engine has been initialized, \c False otherwise.
00263         /// \sa
00264         /// - \ref soundengine_integration_init_advanced
00265         /// - <tt>AK::SoundEngine::Init()</tt>
00266         /// - <tt>AK::SoundEngine::Term()</tt>
00267         AK_EXTERNAPIFUNC( bool, IsInitialized )();
00268 
00269         /// Initialize the sound engine.
00270         /// \warning This function is not thread-safe.
00271         /// \remark The initial settings should be initialized using <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00272         ///         and <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt> to fill the structures with their 
00273         ///         default settings. This is not mandatory, but it helps avoid backward compatibility problems.
00274         ///     
00275         /// \return 
00276         /// - AK_Success if the initialization was successful
00277         /// - AK_MemManagerNotInitialized if the memory manager is not available or not properly initialized
00278         /// - AK_StreamMgrNotInitialized if the stream manager is not available or not properly initialized
00279         /// - AK_SSEInstructionsNotSupported if the machine does not support SSE instruction (only on the PC)
00280         /// - AK_InsufficientMemory or AK_Fail if there is not enough memory available to initialize the sound engine properly
00281         /// - AK_InvalidParameter if some parameters are invalid
00282         /// - AK_Fail if the sound engine is already initialized, or if the provided settings result in insufficient 
00283         /// resources for the initialization.
00284         /// \sa
00285         /// - \ref soundengine_integration_init_advanced
00286         /// - <tt>AK::SoundEngine::Term()</tt>
00287         /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00288         /// - <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt>
00289         AK_EXTERNAPIFUNC( AKRESULT, Init )(
00290             AkInitSettings *            in_pSettings,           ///< Initialization settings (can be NULL, to use the default values)
00291             AkPlatformInitSettings *    in_pPlatformSettings    ///< Platform-specific settings (can be NULL, to use the default values)
00292             );
00293 
00294         /// Gets the default values of the platform-independent initialization settings.
00295         /// \warning This function is not thread-safe.
00296         /// \sa
00297         /// - \ref soundengine_integration_init_advanced
00298         /// - <tt>AK::SoundEngine::Init()</tt>
00299         /// - <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt>
00300         AK_EXTERNAPIFUNC( void, GetDefaultInitSettings )(
00301             AkInitSettings &            out_settings            ///< Returned default platform-independent sound engine settings
00302             );
00303 
00304         /// Gets the default values of the platform-specific initialization settings.
00305         ///
00306         /// Windows Specific:
00307         ///     When initializing for Windows platform, the HWND value returned in the 
00308         ///     AkPlatformInitSettings structure is the foreground HWND at the moment of the 
00309         ///     initialization of the sound engine and may not be the correct one for your need.
00310         ///     Each game must specify the HWND that will be passed to DirectSound initialization.
00311         ///     It is required that each game provides the correct HWND to be used or it could cause
00312         ///     one of the following problem:
00313         ///             - Random Sound engine initialization failure.
00314         ///             - Audio focus to be located on the wrong window.
00315         ///
00316         /// \warning This function is not thread-safe.
00317         /// \sa 
00318         /// - \ref soundengine_integration_init_advanced
00319         /// - <tt>AK::SoundEngine::Init()</tt>
00320         /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00321         AK_EXTERNAPIFUNC( void, GetDefaultPlatformInitSettings )(
00322             AkPlatformInitSettings &    out_platformSettings    ///< Returned default platform-specific sound engine settings
00323             );
00324         
00325         /// Terminates the sound engine.
00326         /// If some sounds are still playing or events are still being processed when this function is 
00327         /// called, they will be stopped.
00328         /// \warning This function is not thread-safe.
00329         /// \warning Before calling Term, you must ensure that no other thread is accessing the sound engine.
00330         /// \sa 
00331         /// - \ref soundengine_integration_init_advanced
00332         /// - <tt>AK::SoundEngine::Init()</tt>
00333         AK_EXTERNAPIFUNC( void, Term )();
00334 
00335         /// Gets the configured audio settings.
00336         /// Call this function to get the configured audio settings.
00337         /// 
00338         /// \warning This function is not thread-safe.
00339         /// \warning Call this function only after the sound engine has been properly initialized.
00340         AK_EXTERNAPIFUNC( AKRESULT, GetAudioSettings )(
00341             AkAudioSettings &   out_audioSettings   ///< Returned audio settings
00342             );
00343 
00344         /// Gets the output speaker configuration of the specified output.
00345         /// Call this function to get the speaker configuration of the output (which may not correspond
00346         /// to the physical output format of the platform, in the case of downmixing provided by the platform itself). 
00347         /// You may initialize the sound engine with a user-specified configuration, but the resulting 
00348         /// configuration is determined by the sound engine, based on the platform, output type and
00349         /// platform settings (for e.g. system menu or control panel option). 
00350         /// 
00351         /// \warning Call this function only after the sound engine has been properly initialized. If you are initializing the sound engine with AkInitSettings::bUseLEngineThread to false, it is required to call RenderAudio() at least once before calling this function to complete the sound engine initialization.
00352         /// \return The output configuration. An empty AkChannelConfig (!AkChannelConfig::IsValid()) if device does not exist.
00353         /// \sa 
00354         /// - AkSpeakerConfig.h
00355         /// - AkOutputSettings
00356         AK_EXTERNAPIFUNC( AkChannelConfig, GetSpeakerConfiguration )(
00357             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00358             );
00359 
00360         /// Gets the panning rule of the specified output.
00361         /// \warning Call this function only after the sound engine has been properly initialized.
00362         /// \return One of the supported configuration: 
00363         /// - AkPanningRule_Speakers
00364         /// - AkPanningRule_Headphone
00365         /// \sa 
00366         /// - AkSpeakerConfig.h
00367         AK_EXTERNAPIFUNC( AKRESULT, GetPanningRule )(
00368             AkPanningRule &     out_ePanningRule,           ///< Returned panning rule (AkPanningRule_Speakers or AkPanningRule_Headphone) for given output.
00369             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00370             );
00371 
00372         /// Sets the panning rule of the specified output.
00373         /// This may be changed anytime once the sound engine is initialized.
00374         /// \warning This function posts a message through the sound engine's internal message queue, whereas GetPanningRule() queries the current panning rule directly.
00375         AK_EXTERNAPIFUNC( AKRESULT, SetPanningRule )( 
00376             AkPanningRule       in_ePanningRule,            ///< Panning rule.
00377             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00378             );
00379 
00380         /// Gets speaker angles of the specified device. Speaker angles are used for 3D positioning of sounds over standard configurations.
00381         /// Note that the current version of Wwise only supports positioning on the plane.
00382         /// The speaker angles are expressed as an array of loudspeaker pairs, in degrees, relative to azimuth ]0,180].
00383         /// Supported loudspeaker setups are always symmetric; the center speaker is always in the middle and thus not specified by angles.
00384         /// Angles must be set in ascending order. 
00385         /// You may call this function with io_pfSpeakerAngles set to NULL to get the expected number of angle values in io_uNumAngles, 
00386         /// in order to allocate your array correctly. You may also obtain this number by calling
00387         /// AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ).
00388         /// If io_pfSpeakerAngles is not NULL, the array is filled with up to io_uNumAngles.
00389         /// Typical usage:
00390         /// - AkUInt32 uNumAngles;
00391         /// - GetSpeakerAngles( NULL, uNumAngles, AkOutput_Main );
00392         /// - AkReal32 * pfSpeakerAngles = AkAlloca( uNumAngles * sizeof(AkReal32) );
00393         /// - GetSpeakerAngles( pfSpeakerAngles, uNumAngles, AkOutput_Main );
00394         /// \aknote 
00395         /// On most platforms, the angle set on the plane consists of 3 angles, to account for 7.1. 
00396         /// - When panning to stereo (speaker mode, see <tt>AK::SoundEngine::SetPanningRule()</tt>), only angle[0] is used, and 3D sounds in the back of the listener are mirrored to the front. 
00397         /// - When panning to 5.1, the front speakers use angle[0], and the surround speakers use (angle[2] - angle[1]) / 2.
00398         /// \endaknote
00399         /// \warning Call this function only after the sound engine has been properly initialized.
00400         /// \return AK_Success if device exists.
00401         /// \sa SetSpeakerAngles()
00402         AK_EXTERNAPIFUNC( AKRESULT, GetSpeakerAngles )(
00403             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.
00404             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 AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ), or just the latter if io_pfSpeakerAngles is NULL.
00405             AkReal32 &          out_fHeightAngle,           ///< Elevation of the height layer, in degrees relative to the plane [-90,90].
00406             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output         
00407             );
00408         
00409         /// Sets speaker angles of the specified device. Speaker angles are used for 3D positioning of sounds over standard configurations.
00410         /// Note that the current version of Wwise only supports positioning on the plane.
00411         /// The speaker angles are expressed as an array of loudspeaker pairs, in degrees, relative to azimuth ]0,180].
00412         /// Supported loudspeaker setups are always symmetric; the center speaker is always in the middle and thus not specified by angles.
00413         /// Angles must be set in ascending order. 
00414         /// Typical usage: 
00415         /// - Initialize the sound engine and/or add secondary output(s).
00416         /// - Get number of speaker angles and their value into an array using GetSpeakerAngles().
00417         /// - Modify the angles and call SetSpeakerAngles().
00418         /// This function posts a message to the audio thread through the command queue, so it is thread safe. However the result may not be immediately read with GetSpeakerAngles().
00419         /// \warning This function only applies to configurations (or subset of these configurations) that are standard and whose speakers are on the plane (2D).
00420         /// \return AK_Success if successful.
00421         /// \sa GetSpeakerAngles()
00422         AK_EXTERNAPIFUNC( AKRESULT, SetSpeakerAngles )(
00423             const AkReal32 *    in_pfSpeakerAngles,         ///< Array of loudspeaker pair angles, in degrees relative to azimuth [0,180].
00424             AkUInt32            in_uNumAngles,              ///< Number of elements in in_pfSpeakerAngles. It must correspond to AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ) (the value returned by GetSpeakerAngles()).
00425             AkReal32            in_fHeightAngle,            ///< Elevation of the height layer, in degrees relative to the plane  [-90,90].
00426             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output         
00427             );
00428 
00429         /// Allows the game to set the volume threshold to be used by the sound engine to determine if a voice must go virtual.
00430         /// This may be changed anytime once the sound engine was initialized.
00431         /// If this function is not called, the used value will be the value specified in the platform specific project settings.
00432         /// \return 
00433         /// - AK_InvalidParameter if the threshold was not between 0 and -96.3 dB.
00434         /// - AK_Success if successful
00435         AK_EXTERNAPIFUNC( AKRESULT, SetVolumeThreshold )( 
00436             AkReal32 in_fVolumeThresholdDB ///< Volume Threshold, must be a value between 0 and -96.3 dB
00437             );
00438 
00439         /// Allows the game to set the maximum number of non virtual voices to be played simultaneously.
00440         /// This may be changed anytime once the sound engine was initialized.
00441         /// If this function is not called, the used value will be the value specified in the platform specific project settings.
00442         /// \return 
00443         /// - AK_InvalidParameter if the threshold was not between 1 and MaxUInt16.
00444         /// - AK_Success if successful
00445         AK_EXTERNAPIFUNC( AKRESULT, SetMaxNumVoicesLimit )( 
00446             AkUInt16 in_maxNumberVoices ///< Maximum number of non-virtual voices.
00447             );
00448                 
00449         //@}
00450 
00451         ////////////////////////////////////////////////////////////////////////
00452         /// @name Rendering Audio
00453         //@{
00454 
00455         /// Processes all commands in the sound engine's command queue.
00456         /// This method has to be called periodically (usually once per game frame).
00457         /// \sa 
00458         /// - \ref concept_events
00459         /// - \ref soundengine_events
00460         /// - <tt>AK::SoundEngine::PostEvent()</tt>
00461         /// \return Always returns AK_Success
00462         AK_EXTERNAPIFUNC( AKRESULT, RenderAudio )( 
00463             bool in_bAllowSyncRender = true             ///< When AkInitSettings::bUseLEngineThread is false, RenderAudio may generate an audio buffer -- unless in_bAllowSyncRender is set to false. Use in_bAllowSyncRender=false when calling RenderAudio from a Sound Engine callback.
00464             );
00465 
00466         //@}
00467 
00468         ////////////////////////////////////////////////////////////////////////
00469         /// @name Component Registration
00470         //@{
00471 
00472         /// Query interface to global plug-in context used for plug-in registration/initialization.
00473         /// \return Global plug-in context.
00474         AK_EXTERNAPIFUNC(AK::IAkGlobalPluginContext *, GetGlobalPluginContext)();
00475 
00476         /// Registers a plug-in with the sound engine and sets the callback functions to create the 
00477         /// plug-in and its parameter node.  
00478         /// \aknote 
00479         /// This function is deprecated. Registration is now automatic if you link plug-ins statically. If plug-ins are dynamic libraries (such as DLLs or SOs), use \c RegisterPluginDLL.
00480         /// \endaknote
00481         /// \sa
00482         /// - \ref register_effects
00483         /// - \ref plugin_xml
00484         /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
00485         /// - Insufficient memory to register the plug-in
00486         /// - Plug-in ID already registered
00487         /// \remarks
00488         /// Codecs and plug-ins must be registered before loading banks that use them.\n
00489         /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
00490         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
00491         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
00492         /// posting the event will fail.
00493         AK_EXTERNAPIFUNC( AKRESULT, RegisterPlugin )( 
00494             AkPluginType in_eType,                      ///< Plug-in type (for example, source or effect)
00495             AkUInt32 in_ulCompanyID,                    ///< Company identifier (as declared in the plug-in description XML file)
00496             AkUInt32 in_ulPluginID,                     ///< Plug-in identifier (as declared in the plug-in description XML file)
00497             AkCreatePluginCallback in_pCreateFunc,      ///< Pointer to the plug-in's creation function
00498             AkCreateParamCallback in_pCreateParamFunc   ///< Pointer to the plug-in's parameter node creation function
00499             );
00500 
00501         /// Loads a plug-in dynamic library and registers it with the sound engine.  
00502         /// With dynamic linking, all plugins are automatically registered.
00503         /// The plug-in DLL must be in the OS-specific library path or in the same location as the executable. If not, set AkInitSettings.szPluginDLLPath.
00504         /// \return 
00505         /// - Ak_Success if successful.  
00506         /// - AK_FileNotFound if the DLL is not found in the OS path or if it has extraneous dependencies not found.  
00507         /// - AK_InvalidFile if the symbol g_pAKPluginList is not exported by the dynamic library
00508         AK_EXTERNAPIFUNC( AKRESULT, RegisterPluginDLL ) (
00509             const AkOSChar* in_DllName,                 ///< Name of the DLL to load, without "lib" prefix or extension.  
00510             const AkOSChar* in_DllPath = NULL           ///< Optional path to the DLL. Will override szPLuginDLLPath that was set in AkInitSettings.
00511             );
00512         
00513         /// Registers a codec type with the sound engine and set the callback functions to create the 
00514         /// codec's file source and bank source nodes.
00515         /// \aknote 
00516         /// This function is deprecated. Registration is now automatic if you link plugins statically. If plugins are dynamic libraries (such as DLLs or SOs), use RegisterPluginDLL.
00517         /// \endaknote      
00518         /// \sa 
00519         /// - \ref register_effects
00520         /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided, or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
00521         /// - Insufficient memory to register the codec
00522         /// - Codec ID already registered
00523         /// \remarks
00524         /// Codecs and plug-ins must be registered before loading banks that use them.\n
00525         /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
00526         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
00527         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
00528         /// posting the Event will fail.
00529         AK_EXTERNAPIFUNC( AKRESULT, RegisterCodec )( 
00530             AkUInt32 in_ulCompanyID,                        ///< Company identifier (as declared in the plug-in description XML file)
00531             AkUInt32 in_ulCodecID,                          ///< Codec identifier (as declared in the plug-in description XML file)
00532             AkCreateFileSourceCallback in_pFileCreateFunc,  ///< Pointer to the codec's file source node creation function
00533             AkCreateBankSourceCallback in_pBankCreateFunc   ///< Pointer to the codec's bank source node creation function
00534             );
00535 
00536         /// Registers a global callback function. This function will be called from the audio rendering thread, at the
00537         /// location specified by in_eLocation. This function will also be called from the thread calling           
00538         /// AK::SoundEngine::Term with in_eLocation set to AkGlobalCallbackLocation_Term.
00539         /// For example, in order to be called at every audio rendering pass, and once during teardown for releasing resources, you would call 
00540         /// RegisterGlobalCallback(myCallback, AkGlobalCallbackLocation_BeginRender  | AkGlobalCallbackLocation_Term, myCookie, AkPluginTypeNone, 0, 0);  
00541         /// \remarks
00542         /// A Plugin Type, Company ID and Plugin ID can be provided to this function to enable timing in the performance montior.
00543         /// If the callback is being timed, it will contribute to the Total Plug-in CPU measurement, and also appear in the Plug-ins tab of the Advanced Profiler by plug-in type and ID. 
00544         /// It is illegal to call this function while already inside of a global callback.
00545         /// This function might stall for several milliseconds before returning.
00546         /// \sa 
00547         /// - <tt>AK::SoundEngine::UnregisterGlobalCallback()</tt>
00548         /// - AkGlobalCallbackFunc
00549         /// - AkGlobalCallbackLocation
00550         AK_EXTERNAPIFUNC(AKRESULT, RegisterGlobalCallback)(
00551             AkGlobalCallbackFunc in_pCallback,              ///< Function to register as a global callback.
00552             AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender, ///< Callback location defined in AkGlobalCallbackLocation. Bitwise OR multiple locations if needed.
00553             void * in_pCookie = NULL,                       ///< User cookie.
00554             AkPluginType in_eType = AkPluginTypeNone,       ///< Plug-in type (for example, source or effect). AkPluginTypeNone for no timing.
00555             AkUInt32 in_ulCompanyID = 0,                    ///< Company identifier (as declared in the plug-in description XML file). 0 for no timing. 
00556             AkUInt32 in_ulPluginID = 0                      ///< Plug-in identifier (as declared in the plug-in description XML file). 0 for no timing. 
00557             );
00558 
00559         /// Unregisters a global callback function, previously registered using RegisterGlobalCallback.
00560         /// \remarks
00561         /// It is legal to call this function while already inside of a global callback, If it is unregistering itself and not
00562         /// another callback.
00563         /// This function might stall for several milliseconds before returning.
00564         /// \sa 
00565         /// - <tt>AK::SoundEngine::RegisterGlobalCallback()</tt>
00566         /// - AkGlobalCallbackFunc
00567         /// - AkGlobalCallbackLocation
00568         AK_EXTERNAPIFUNC(AKRESULT, UnregisterGlobalCallback)(
00569             AkGlobalCallbackFunc in_pCallback,              ///< Function to unregister as a global callback.
00570             AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender ///< Must match in_eLocation as passed to RegisterGlobalCallback for this callback.
00571             );
00572 
00573         /// Registers a callback for the Audio Device status changes.  
00574         /// The callback will be called from the audio thread
00575         /// Can be called prior to AK::SoundEngine::Init
00576         AK_EXTERNAPIFUNC(AKRESULT, RegisterAudioDeviceStatusCallback)(
00577             AK::AkDeviceStatusCallbackFunc in_pCallback             ///< Function to register as a status callback.                     
00578             );
00579 
00580         /// Unregisters the callback for the Audio Device status changes, registered by RegisterAudioDeviceStatusCallback               
00581         AK_EXTERNAPIFUNC(AKRESULT, UnregisterAudioDeviceStatusCallback)();
00582         //@}
00583 
00584 #ifdef AK_SUPPORT_WCHAR
00585         ////////////////////////////////////////////////////////////////////////
00586         /// @name Getting ID from strings
00587         //@{
00588 
00589         /// Universal converter from Unicode string to ID for the sound engine.
00590         /// This function will hash the name based on a algorithm ( provided at : /AK/Tools/Common/AkFNVHash.h )
00591         /// Note:
00592         ///     This function does return a AkUInt32, which is totally compatible with:
00593         ///     AkUniqueID, AkStateGroupID, AkStateID, AkSwitchGroupID, AkSwitchStateID, AkRtpcID, and so on...
00594         /// \sa
00595         /// - <tt>AK::SoundEngine::PostEvent</tt>
00596         /// - <tt>AK::SoundEngine::SetRTPCValue</tt>
00597         /// - <tt>AK::SoundEngine::SetSwitch</tt>
00598         /// - <tt>AK::SoundEngine::SetState</tt>
00599         /// - <tt>AK::SoundEngine::PostTrigger</tt>
00600         /// - <tt>AK::SoundEngine::SetGameObjectAuxSendValues</tt>
00601         /// - <tt>AK::SoundEngine::LoadBank</tt>
00602         /// - <tt>AK::SoundEngine::UnloadBank</tt>
00603         /// - <tt>AK::SoundEngine::PrepareEvent</tt>
00604         /// - <tt>AK::SoundEngine::PrepareGameSyncs</tt>
00605         AK_EXTERNAPIFUNC( AkUInt32, GetIDFromString )( const wchar_t* in_pszString );
00606 #endif //AK_SUPPORT_WCHAR
00607 
00608         /// Universal converter from string to ID for the sound engine.
00609         /// This function will hash the name based on a algorithm ( provided at : /AK/Tools/Common/AkFNVHash.h )
00610         /// Note:
00611         ///     This function does return a AkUInt32, which is totally compatible with:
00612         ///     AkUniqueID, AkStateGroupID, AkStateID, AkSwitchGroupID, AkSwitchStateID, AkRtpcID, and so on...
00613         /// \sa
00614         /// - <tt>AK::SoundEngine::PostEvent</tt>
00615         /// - <tt>AK::SoundEngine::SetRTPCValue</tt>
00616         /// - <tt>AK::SoundEngine::SetSwitch</tt>
00617         /// - <tt>AK::SoundEngine::SetState</tt>
00618         /// - <tt>AK::SoundEngine::PostTrigger</tt>
00619         /// - <tt>AK::SoundEngine::SetGameObjectAuxSendValues</tt>
00620         /// - <tt>AK::SoundEngine::LoadBank</tt>
00621         /// - <tt>AK::SoundEngine::UnloadBank</tt>
00622         /// - <tt>AK::SoundEngine::PrepareEvent</tt>
00623         /// - <tt>AK::SoundEngine::PrepareGameSyncs</tt>
00624         AK_EXTERNAPIFUNC( AkUInt32, GetIDFromString )( const char* in_pszString );
00625 
00626         //@}
00627 
00628         ////////////////////////////////////////////////////////////////////////
00629         /// @name Event Management
00630         //@{
00631 
00632         /// Asynchronously posts an Event to the sound engine (by event ID).
00633         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00634         /// An array of wave file sources can be provided to resolve External Sources triggered by the event. 
00635         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00636         /// \remarks
00637         /// If used, the array of external sources should contain the information for each external source triggered by the
00638         /// event. When triggering an event with multiple external sources, you need to differentiate each source 
00639         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00640         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00641         /// (therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures.
00642         /// \endaknote
00643         /// \sa 
00644         /// - \ref concept_events
00645         /// - \ref integrating_external_sources
00646         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00647         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00648         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00649         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00650             AkUniqueID in_eventID,                          ///< Unique ID of the event
00651             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00652             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00653             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00654             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information
00655             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00656             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00657             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.
00658             );
00659 
00660 #ifdef AK_SUPPORT_WCHAR
00661         /// Posts an Event to the sound engine (by Event name), using callbacks.
00662         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00663         /// An array of wave file sources can be provided to resolve External Sources triggered by the event. 
00664         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00665         /// \remarks
00666         /// If used, the array of external sources should contain the information for each external source triggered by the
00667         /// event. When triggering an event with multiple external sources, you need to differentiate each source 
00668         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00669         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00670         /// (therefore have a unique cookie) in order to tell them appart when filling the AkExternalSourceInfo structures.
00671         /// \endaknote
00672         /// \sa 
00673         /// - \ref concept_events
00674         /// - \ref integrating_external_sources
00675         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00676         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00677         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00678         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00679             const wchar_t* in_pszEventName,                 ///< Name of the event
00680             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00681             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00682             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00683             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information.
00684             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00685             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00686             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.
00687             );
00688 #endif //AK_SUPPORT_WCHAR
00689 
00690         /// Posts an Event to the sound engine (by Event name), using callbacks.
00691         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00692         /// An array of Wave file sources can be provided to resolve External Sources triggered by the event. P
00693         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00694         /// \remarks
00695         /// If used, the array of external sources should contain the information for each external source triggered by the
00696         /// event. When triggering an Event with multiple external sources, you need to differentiate each source 
00697         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00698         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00699         /// (therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures.
00700         /// \endaknote
00701         /// \sa 
00702         /// - \ref concept_events
00703         /// - \ref integrating_external_sources
00704         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00705         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00706         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00707         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00708             const char* in_pszEventName,                    ///< Name of the event
00709             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00710             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00711             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00712             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information.
00713             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00714             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00715             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.
00716             );
00717 
00718         // If you modify AkActionOnEventType, don't forget to modify the WAAPI validation schema accordingly.
00719 
00720         /// AkActionOnEventType
00721         /// \sa
00722         /// - <tt>AK::SoundEngine::ExecuteActionOnEvent()</tt>
00723         enum AkActionOnEventType
00724         {
00725             AkActionOnEventType_Stop    = 0,            ///< Stop
00726             AkActionOnEventType_Pause   = 1,            ///< Pause
00727             AkActionOnEventType_Resume  = 2,            ///< Resume
00728             AkActionOnEventType_Break   = 3,            ///< Break
00729             AkActionOnEventType_ReleaseEnvelope = 4     ///< Release envelope
00730         };
00731 
00732         /// Executes an action on all nodes that are referenced in the specified event in an action of type play.
00733         /// \sa
00734         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00735         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00736             AkUniqueID in_eventID,                                              ///< Unique ID of the event
00737             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00738             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00739             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00740             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00741             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00742             );
00743 
00744 #ifdef AK_SUPPORT_WCHAR
00745         /// Executes an action on all nodes that are referenced in the specified event in an action of type play.
00746         /// \sa
00747         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00748         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00749             const wchar_t* in_pszEventName,                                     ///< Name of the event
00750             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00751             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00752             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00753             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00754             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00755             );
00756 #endif //AK_SUPPORT_WCHAR
00757 
00758         /// Executes an Action on all nodes that are referenced in the specified Event in an Action of type Play.
00759         /// \sa
00760         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00761         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00762             const char* in_pszEventName,                                        ///< Name of the event
00763             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00764             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00765             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00766             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00767             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00768             );
00769 
00770 
00771         /// Executes a number of MIDI Events on all nodes that are referenced in the specified Event in an Action of type Play.
00772         /// Each MIDI event will be posted in AkMIDIPost::uOffset samples from the start of the current frame. The duration of
00773         /// a sample can be determined from the sound engine's audio settings, via a call to AK::SoundEngine::GetAudioSettings.
00774         /// \sa
00775         /// - <tt>AK::SoundEngine::GetAudioSettings</tt>
00776         /// - <tt>AK::SoundEngine::StopMIDIOnEvent</tt>
00777         AK_EXTERNAPIFUNC( AKRESULT, PostMIDIOnEvent )(
00778             AkUniqueID in_eventID,                                          ///< Unique ID of the Event
00779             AkGameObjectID in_gameObjectID,                                 ///< Associated game object ID
00780             AkMIDIPost* in_pPosts,                                          ///< MIDI Events to post
00781             AkUInt16 in_uNumPosts                                           ///< Number of MIDI Events to post
00782             );
00783 
00784         /// Stops MIDI notes on all nodes that are referenced in the specified event in an action of type play,
00785         /// with the specified Game Object. Invalid parameters are interpreted as wildcards. For example, calling
00786         /// this function with in_eventID set to AK_INVALID_UNIQUE_ID will stop all MIDI notes for Game Object
00787         /// in_gameObjectID.
00788         /// \sa
00789         /// - <tt>AK::SoundEngine::PostMIDIOnEvent</tt>
00790         AK_EXTERNAPIFUNC( AKRESULT, StopMIDIOnEvent )(
00791             AkUniqueID in_eventID = AK_INVALID_UNIQUE_ID,                   ///< Unique ID of the Event
00792             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT         ///< Associated game object ID
00793             );
00794 
00795 
00796         /// Starts streaming the first part of all streamed files referenced by an Event into a cache buffer. Caching streams are serviced when no other streams require the 
00797         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00798         /// uMaxCachePinnedBytes is exceeded.  
00799         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00800         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00801         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00802         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00803         /// \remarks If the event references files that are chosen based on a State Group (via a switch container), all files in all states will be cached. Those in the current active state
00804         /// will get cached with active priority, while all other files will get cached with inactive priority.
00805         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00806         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00807         /// \sa
00808         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00809         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00810         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00811         /// - AkFileSystemFlags
00812         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00813             AkUniqueID in_eventID,                                          ///< Unique ID of the event
00814             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00815             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00816             );
00817 
00818 #ifdef AK_SUPPORT_WCHAR
00819         /// Starts streaming the first part of all streamed files referenced by an event into a cache buffer. Caching streams are serviced when no other streams require the 
00820         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00821         /// uMaxCachePinnedBytes is exceeded.  
00822         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00823         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00824         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00825         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00826         /// \remarks If the event references files that are chosen based on a State Group (via a Switch Container), all files in all states will be cached. Those in the current active state
00827         /// will get cached with active priority, while all other files will get cached with inactive priority.
00828         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00829         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00830         /// \sa
00831         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00832         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00833         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00834         /// - AkFileSystemFlags
00835         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00836             const wchar_t* in_pszEventName,                                 ///< Name of the event
00837             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00838             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00839             );
00840 #endif //AK_SUPPORT_WCHAR
00841 
00842         /// Starts streaming the first part of all streamed files referenced by an event into a cache buffer. Caching streams are serviced when no other streams require the 
00843         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00844         /// uMaxCachePinnedBytes is exceeded.  
00845         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00846         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00847         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00848         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00849         /// \remarks If the event references files that are chosen based on a State Group (via a switch container), all files in all states will be cached. Those in the current active state
00850         /// will get cached with active priority, while all other files will get cached with inactive priority.
00851         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00852         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00853         /// \sa
00854         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00855         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00856         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00857         /// - AkFileSystemFlags
00858         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00859             const char* in_pszEventName,                                    ///< Name of the event
00860             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00861             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00862             );
00863 
00864         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00865         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00866         /// \sa
00867         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00868         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00869         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00870             AkUniqueID in_eventID                                           ///< Unique ID of the event
00871             );  
00872 
00873 #ifdef AK_SUPPORT_WCHAR
00874         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00875         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00876         /// \sa
00877         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00878         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00879         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00880             const wchar_t* in_pszEventName                                  ///< Name of the event
00881             );
00882 #endif //AK_SUPPORT_WCHAR
00883 
00884         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00885         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00886         /// \sa
00887         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00888         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00889         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00890             const char* in_pszEventName                                     ///< Name of the event
00891             );
00892 
00893         /// Returns information about an Event that was requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00894         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00895         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00896         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see \c AkDeviceSettings 
00897         /// \sa
00898         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00899         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00900         /// - AkDeviceSettings
00901         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00902             AkUniqueID in_eventID,                                          ///< Unique ID of the event
00903             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00904             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00905             );
00906 
00907         /// Returns information about an Event that was requested to be pinned into cache via \c <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00908         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00909         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00910         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see AkDeviceSettings 
00911         /// \sa
00912         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00913         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00914         /// - AkDeviceSettings
00915         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00916             const char* in_pszEventName,                                    ///< Name of the event
00917             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00918             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00919             );
00920 
00921 #ifdef AK_SUPPORT_WCHAR
00922         /// Returns information about an Event that was requested to be pinned into cache via \c <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00923         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00924         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00925         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see AkDeviceSettings 
00926         /// \sa
00927         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00928         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00929         /// - AkDeviceSettings
00930         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00931             const wchar_t* in_pszEventName,                                 ///< Name of the event
00932             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00933             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00934             );
00935 #endif
00936 
00937         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
00938         ///
00939         /// Notes:
00940         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
00941         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
00942         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
00943         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
00944         ///         the sound that is currently playing is the first sound of the sequence.
00945         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
00946         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
00947         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
00948         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
00949         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
00950         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
00951         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
00952         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
00953         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
00954         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
00955         ///         the audio thread consumes it (after a call to RenderAudio()). 
00956         ///
00957         /// Notes specific to Music Segments:
00958         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
00959         ///         value to seek within the Pre-Entry.
00960         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
00961         ///         in order to restart them if required.
00962         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
00963         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
00964         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
00965         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
00966         ///         the exact position of a segment. Also, the segment will be silent during that time
00967         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
00968         ///         also informs you about the remaining look-ahead time.  
00969         ///
00970         /// Notes specific to Music Switch Containers:
00971         ///     - Seeking triggers a music transition towards the current (or target) segment.
00972         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
00973         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
00974         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
00975         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
00976         ///
00977         /// \sa
00978         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00979         /// - <tt>AK::SoundEngine::PostEvent()</tt>
00980         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00981         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
00982         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
00983             AkUniqueID in_eventID,                                      ///< Unique ID of the event
00984             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
00985             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
00986             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)
00987             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.
00988             );
00989 
00990 #ifdef AK_SUPPORT_WCHAR
00991         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
00992         ///
00993         /// Notes:
00994         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
00995         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
00996         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
00997         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
00998         ///         the sound that is currently playing is the first sound of the sequence.
00999         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01000         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01001         ///         value to seek within the Pre-Entry.
01002         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
01003         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
01004         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01005         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01006         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01007         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01008         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01009         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01010         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01011         ///         the audio thread consumes it (after a call to RenderAudio()). 
01012         ///
01013         /// Notes specific to Music Segments:
01014         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01015         ///         value to seek within the Pre-Entry.
01016         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01017         ///         in order to restart them if required.
01018         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01019         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01020         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01021         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01022         ///         the exact position of a segment. Also, the segment will be silent during that time
01023         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01024         ///         also informs you about the remaining look-ahead time. 
01025         ///
01026         /// Notes specific to Music Switch Containers:
01027         ///     - Seeking triggers a music transition towards the current (or target) segment.
01028         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01029         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01030         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01031         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01032         ///
01033         /// \sa
01034         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01035         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01036         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01037         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01038         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01039             const wchar_t* in_pszEventName,                             ///< Name of the event
01040             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01041             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
01042             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)
01043             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01044             );
01045 #endif //AK_SUPPORT_WCHAR
01046 
01047         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01048         ///
01049         /// Notes:
01050         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01051         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01052         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01053         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01054         ///         the sound that is currently playing is the first sound of the sequence.
01055         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01056         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01057         ///         value to seek within the Pre-Entry.
01058         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
01059         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
01060         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01061         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01062         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01063         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01064         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01065         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01066         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01067         ///         the audio thread consumes it (after a call to RenderAudio()). 
01068         ///
01069         /// Notes specific to Music Segments:
01070         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01071         ///         value to seek within the Pre-Entry.
01072         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01073         ///         in order to restart them if required.
01074         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01075         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01076         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01077         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01078         ///         the exact position of a segment. Also, the segment will be silent during that time
01079         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01080         ///         also informs you about the remaining look-ahead time. 
01081         ///
01082         /// Notes specific to Music Switch Containers:
01083         ///     - Seeking triggers a music transition towards the current (or target) segment.
01084         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01085         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01086         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01087         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01088         ///
01089         /// \sa
01090         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01091         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01092         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01093         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01094         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01095             const char* in_pszEventName,                                ///< Name of the event
01096             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01097             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
01098             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01099             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01100             );
01101 
01102         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01103         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01104         ///
01105         /// Notes:
01106         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01107         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01108         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01109         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01110         ///         the sound that is currently playing is the first sound of the sequence.
01111         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01112         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
01113         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01114         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01115         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01116         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01117         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01118         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01119         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01120         ///         the audio thread consumes it (after a call to RenderAudio()). 
01121         ///
01122         /// Notes specific to Music Segments:
01123         ///     - With Music Segments, \c in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01124         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01125         ///         post-exit of a segment using this method. Use absolute values instead.
01126         ///     - Music Segments cannot be looped. You may want to listen to the \c AK_EndOfEvent notification 
01127         ///         in order to restart them if required.
01128         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01129         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01130         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01131         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01132         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01133         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01134         ///         also informs you about the remaining look-ahead time. 
01135         ///
01136         /// Notes specific to Music Switch Containers:
01137         ///     - Seeking triggers a music transition towards the current (or target) segment.
01138         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01139         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01140         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01141         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01142         ///
01143         /// \sa
01144         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01145         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01146         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01147         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01148         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01149             AkUniqueID in_eventID,                                      ///< Unique ID of the event
01150             AkGameObjectID in_gameObjectID ,                            ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01151             AkReal32 in_fPercent,                                       ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01152             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01153             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01154             );
01155 
01156 #ifdef AK_SUPPORT_WCHAR
01157         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01158         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01159         ///
01160         /// Notes:
01161         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01162         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01163         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01164         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01165         ///         the sound that is currently playing is the first sound of the sequence.
01166         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01167         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01168         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01169         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01170         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01171         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01172         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01173         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01174         ///         the audio thread consumes it (after a call to RenderAudio()). 
01175         ///
01176         /// Notes specific to Music Segments:
01177         ///     - With Music Segments, \c in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01178         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01179         ///         post-exit of a segment using this method. Use absolute values instead.
01180         ///     - Music Segments cannot be looped. You may want to listen to the \c AK_EndOfEvent notification 
01181         ///         in order to restart them if required.
01182         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01183         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01184         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01185         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01186         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01187         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01188         ///         also informs you about the remaining look-ahead time. 
01189         ///
01190         /// Notes specific to Music Switch Containers:
01191         ///     - Seeking triggers a music transition towards the current (or target) segment.
01192         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01193         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01194         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01195         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01196         ///
01197         /// \sa
01198         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01199         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01200         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01201         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01202         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01203             const wchar_t* in_pszEventName,                             ///< Name of the event
01204             AkGameObjectID in_gameObjectID ,                            ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01205             AkReal32 in_fPercent ,                                      ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01206             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01207             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01208             );
01209 #endif //AK_SUPPORT_WCHAR
01210 
01211         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01212         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01213         ///
01214         /// Notes:
01215         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01216         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01217         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01218         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01219         ///         the sound that is currently playing is the first sound of the sequence.
01220         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01221         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01222         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01223         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01224         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01225         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01226         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01227         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01228         ///         the audio thread consumes it (after a call to RenderAudio()). 
01229         ///
01230         /// Notes specific to Music Segments:
01231         ///     - With Music Segments, in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01232         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01233         ///         post-exit of a segment using this method. Use absolute values instead.
01234         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01235         ///         in order to restart them if required.
01236         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01237         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01238         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01239         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01240         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01241         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01242         ///         also informs you about the remaining look-ahead time. 
01243         ///
01244         /// Notes specific to Music Switch Containers:
01245         ///     - Seeking triggers a music transition towards the current (or target) segment.
01246         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01247         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01248         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01249         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01250         ///
01251         /// \sa
01252         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01253         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01254         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01255         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01256         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01257             const char* in_pszEventName,                                ///< Name of the event
01258             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01259             AkReal32 in_fPercent,                                       ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01260             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see notes above).    
01261             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01262             );
01263 
01264         /// Cancels all Event callbacks associated with a specific callback cookie.\n
01265         /// \sa 
01266         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01267         AK_EXTERNAPIFUNC( void, CancelEventCallbackCookie )( 
01268             void * in_pCookie                           ///< Callback cookie to be cancelled
01269             );
01270 
01271         /// Cancels all Event callbacks associated with a specific game object.\n
01272         /// \sa 
01273         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01274         AK_EXTERNAPIFUNC( void, CancelEventCallbackGameObject )(
01275             AkGameObjectID in_gameObjectID              ///< ID of the game object to be cancelled
01276             );
01277 
01278         /// Cancels all Event callbacks for a specific playing ID.
01279         /// \sa 
01280         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01281         AK_EXTERNAPIFUNC( void, CancelEventCallback )( 
01282             AkPlayingID in_playingID                    ///< Playing ID of the event that must not use callbacks
01283             );
01284 
01285         /// Gets the current position of the source associated with this playing ID, obtained from PostEvent(). If more than one source is playing,
01286         /// the first to play is returned.
01287         /// Notes:
01288         /// - You need to pass AK_EnableGetSourcePlayPosition to PostEvent() in order to use this function, otherwise
01289         ///     it returns AK_Fail, even if the playing ID is valid.
01290         /// - The source's position is updated at every audio frame, and the time at which this occurs is stored. 
01291         ///     When you call this function from your thread, you therefore query the position that was updated in the previous audio frame.
01292         ///     If in_bExtrapolate is true (default), the returned position is extrapolated using the elapsed time since last 
01293         ///     sound engine update and the source's playback rate.
01294         /// \return AK_Success if successful.
01295         ///         It returns AK_InvalidParameter if the provided pointer is not valid.
01296         ///         It returns AK_Fail if the playing ID is invalid (not playing yet, or finished playing).
01297         /// \sa 
01298         /// - \ref soundengine_query_pos
01299         /// - \ref concept_events
01300         AK_EXTERNAPIFUNC( AKRESULT, GetSourcePlayPosition )(
01301             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01302             AkTimeMs*       out_puPosition,             ///< Position of the source (in ms) associated with the specified playing ID
01303             bool            in_bExtrapolate = true      ///< Position is extrapolated based on time elapsed since last sound engine update.
01304             );
01305 
01306         /// Gets the current position of the sources associated with this playing ID, obtained from PostEvent().
01307         /// Notes:
01308         /// - You need to pass AK_EnableGetSourcePlayPosition to PostEvent() in order to use this function, otherwise
01309         ///     it returns AK_Fail, even if the playing ID is valid.
01310         /// - The source's position is updated at every audio frame, and the time at which this occurs is stored. 
01311         ///     When you call this function from your thread, you therefore query the position that was updated in the previous audio frame.
01312         ///     If in_bExtrapolate is true (default), the returned position is extrapolated using the elapsed time since last 
01313         ///     sound engine update and the source's playback rate.
01314         /// - If 0 is passed in for the number of entries (*in_pcPositions == 0) then only the number of positions will be returned and the
01315         ///     position array (out_puPositions) will not be updated.
01316         /// - The io_pcPositions pointer must be non-NULL.
01317         ///     out_puPositions may be NULL if *io_pcPositions == 0, otherwise it must be non-NULL.
01318         /// \return AK_Success if successful.
01319         ///         It returns AK_InvalidParameter if the provided pointers are not valid.
01320         ///         It returns AK_Fail if the playing ID is invalid (not playing yet, or finished playing).
01321         /// \sa 
01322         /// - \ref soundengine_query_pos
01323         /// - \ref concept_events
01324         AK_EXTERNAPIFUNC(AKRESULT, GetSourcePlayPositions)(
01325             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01326             AkSourcePosition* out_puPositions,          ///< Audio Node IDs and positions of sources associated with the specified playing ID
01327             AkUInt32 *      io_pcPositions,             ///< Number of entries in out_puPositions. Needs to be set to the size of the array: it is adjusted to the actual number of returned entries
01328             bool            in_bExtrapolate = true      ///< Position is extrapolated based on time elapsed since last sound engine update
01329             );
01330 
01331         /// Gets the stream buffering of the sources associated with this playing ID, obtained from PostEvent().
01332         /// Notes:
01333         /// - You need to pass AK_EnableGetSourceStreamBuffering to PostEvent() in order to use this function, otherwise
01334         ///     it returns AK_Fail, even if the playing ID is valid.
01335         /// - The sources stream buffering is updated at every audio frame. If there are multiple sources associated with this playing ID,
01336         ///     the value returned corresponds to the least buffered source. 
01337         /// - The returned buffering status out_bIsBuffering will be true If any of the sources associated with the playing ID are actively being buffered.
01338         ///     It will be false if all of them have reached the end of file, or have reached a state where they are buffered enough and streaming is temporarily idle.
01339         /// - Purely in-memory sources are excluded from this database. If all sources are in-memory, GetSourceStreamBuffering() will return AK_Fail.
01340         /// - The returned buffering amount and state is not completely accurate with some hardware-accelerated codecs. In such cases, the amount of stream buffering is generally underestimated.
01341         ///     On the other hand, it is not guaranteed that the source will be ready to produce data at the next audio frame even if out_bIsBuffering has turned to false.
01342         /// \return 
01343         /// - AK_Success if successful.
01344         /// - AK_Fail if the source data associated with this playing ID is not found, for example if PostEvent() was not called with AK_EnableGetSourceStreamBuffering, or if the header was not parsed.
01345         /// \sa 
01346         /// - \ref concept_events
01347         AK_EXTERNAPIFUNC( AKRESULT, GetSourceStreamBuffering )(
01348             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01349             AkTimeMs &      out_buffering,              ///< Returned amount of buffering (in ms) of the source (or one of the sources) associated with that playing ID
01350             bool &          out_bIsBuffering            ///< Returned buffering status of the source(s) associated with that playing ID
01351             );
01352 
01353         /// Stops the current content playing associated to the specified game object ID.
01354         /// If no game object is specified, all sounds will be stopped.
01355         AK_EXTERNAPIFUNC( void, StopAll )( 
01356             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT ///< (Optional)Specify a game object to stop only playback associated to the provided game object ID.
01357             );
01358 
01359         /// Stop the current content playing associated to the specified playing ID.
01360         /// \aknote 
01361         /// This function is deprecated. Please use ExecuteActionOnPlayingID() in its place.
01362         /// \endaknote
01363         /// \sa
01364         ///  - <tt>AK::SoundEngine::ExecuteActionOnPlayingID()</tt>
01365         AK_EXTERNAPIFUNC( void, StopPlayingID )(
01366             AkPlayingID in_playingID,                                           ///< Playing ID to be stopped.
01367             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
01368             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear    ///< Curve type to be used for the transition
01369             );
01370 
01371         /// Executes an Action on the content associated to the specified playing ID.
01372         /// \sa
01373         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
01374         AK_EXTERNAPIFUNC(void, ExecuteActionOnPlayingID)(
01375             AkActionOnEventType in_ActionType,                                  ///< Action to execute on the specified playing ID.
01376             AkPlayingID in_playingID,                                           ///< Playing ID on which to execute the action.
01377             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
01378             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear    ///< Curve type to be used for the transition
01379             );
01380 
01381         /// Sets the random seed value. Can be used to synchronize randomness
01382         /// across instances of the Sound Engine.
01383         /// \remark This seeds the number generator used for all container randomizations;
01384         ///         since it acts globally, this should be called right before any PostEvent
01385         ///         call where randomness synchronization is required, and cannot guarantee
01386         ///         similar results for continuous containers.
01387         AK_EXTERNAPIFUNC( void, SetRandomSeed )( 
01388             AkUInt32 in_uSeed                                                   ///< Random seed.
01389             );
01390 
01391         /// Mutes/Unmutes the busses tagged as background music.  
01392         /// This is automatically called for platforms that have user-music support.
01393         /// This function is provided to give the same behavior on platforms that don't have user-music support.
01394         AK_EXTERNAPIFUNC( void, MuteBackgroundMusic ) (
01395             bool in_bMute ///< Sets true to mute, false to unmute.
01396             );
01397         //@}
01398 
01399         /// Gets the state of the Background Music busses. This state is either set directly 
01400         /// with \c AK::SoundEngine::MuteBackgroundMusic or by the OS, if it has User Music services.
01401         /// \return true if the background music busses are muted, false if not.
01402         AK_EXTERNAPIFUNC(bool, GetBackgroundMusicMute) ();
01403         //@}
01404 
01405 
01406         /// Sends custom game data to a plug-in that resides on a bus (insert Effect or mixer plug-in).
01407         /// Data will be copied and stored into a separate list.
01408         /// Previous entry is deleted when a new one is sent.
01409         /// Sets the data pointer to NULL to clear item from the list.
01410         /// \aknote The plug-in type and ID is passed and matched with plugins set on the desired bus. 
01411         /// This means that you cannot send different data to various instances of the plug-in on a same bus.\endaknote
01412         /// \return AK_Success if data was sent successfully.
01413         AK_EXTERNAPIFUNC( AKRESULT, SendPluginCustomGameData ) (
01414             AkUniqueID in_busID,            ///< Bus ID
01415             AkGameObjectID in_busObjectID,  ///< Bus Object ID. Pass AK_INVALID_GAME_OBJECT to send custom data with global scope. Game object scope supersedes global scope, as with RTPCs. 
01416             AkPluginType in_eType,          ///< Plug-in type (for example, source or effect)
01417             AkUInt32 in_uCompanyID,     ///< Company identifier (as declared in the plug-in description XML file)
01418             AkUInt32 in_uPluginID,          ///< Plug-in identifier (as declared in the plug-in description XML file)
01419             const void* in_pData,           ///< The data blob
01420             AkUInt32 in_uSizeInBytes        ///< Size of data
01421             );
01422         //@}
01423 
01424         ////////////////////////////////////////////////////////////////////////
01425         /// @name Game Objects
01426         //@{
01427         
01428         /// Registers a game object.
01429         /// \return
01430         /// - AK_Success if successful
01431         /// - AK_Fail if the specified AkGameObjectID is invalid (0 and -1 are invalid)
01432         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01433         ///         matter how many times it has been registered.
01434         /// \sa 
01435         /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01436         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01437         /// - \ref concept_gameobjects
01438         AK_EXTERNAPIFUNC(AKRESULT, RegisterGameObj)(
01439             AkGameObjectID in_gameObjectID                              ///< ID of the game object to be registered         
01440             );
01441 
01442         /// Registers a game object.
01443         /// \return
01444         /// - AK_Success if successful
01445         /// - AK_Fail if the specified AkGameObjectID is invalid (0 and -1 are invalid)
01446         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01447         ///         matter how many times it has been registered.
01448         /// \sa 
01449         /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01450         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01451         /// - \ref concept_gameobjects
01452         AK_EXTERNAPIFUNC( AKRESULT, RegisterGameObj )(
01453             AkGameObjectID in_gameObjectID,                         ///< ID of the game object to be registered
01454             const char * in_pszObjName                              ///< Name of the game object (for monitoring purpose)
01455             );
01456 
01457         /// Unregisters a game object.
01458         /// \return 
01459         /// - AK_Success if successful
01460         /// - AK_Fail if the specified AkGameObjectID is invalid (0 is an invalid ID)
01461         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01462         ///         matter how many times it has been registered. Unregistering a game object while it is 
01463         ///         in use is allowed, but the control over the parameters of this game object is lost.
01464         ///         For example, say a sound associated with this game object is a 3D moving sound. This sound will 
01465         ///         stop moving when the game object is unregistered, and there will be no way to regain control over the game object.
01466         /// \sa 
01467         /// - <tt>AK::SoundEngine::RegisterGameObj()</tt>
01468         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01469         /// - \ref concept_gameobjects
01470         AK_EXTERNAPIFUNC( AKRESULT, UnregisterGameObj )(
01471             AkGameObjectID in_gameObjectID              ///< ID of the game object to be unregistered. Use 
01472                                                         /// AK_INVALID_GAME_OBJECT to unregister all game objects.
01473             );
01474 
01475     /// Unregister all game objects, or all game objects with a particular matching set of property flags.
01476     /// This function to can be used to unregister all game objects.  
01477     /// \return
01478     /// - AK_Success if successful
01479     /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01480     ///         matter how many times it has been registered. Unregistering a game object while it is 
01481     ///         in use is allowed, but the control over the parameters of this game object is lost.
01482     ///         For example, if a sound associated with this game object is a 3D moving sound, it will 
01483     ///         stop moving once the game object is unregistered, and there will be no way to recover 
01484     ///         the control over this game object.
01485     /// \sa 
01486     /// - <tt>AK::SoundEngine::RegisterGameObj()</tt>
01487     /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01488     /// - \ref concept_gameobjects
01489     AK_EXTERNAPIFUNC( AKRESULT, UnregisterAllGameObj )(
01490         );
01491 
01492         /// Sets the position of a game object.
01493         /// \warning The object's orientation vector (in_Position.Orientation) must be normalized.
01494         /// \return 
01495         /// - AK_Success when successful
01496         /// - AK_InvalidParameter if parameters are not valid.
01497         /// \sa 
01498         /// - \ref soundengine_3dpositions
01499         AK_EXTERNAPIFUNC( AKRESULT, SetPosition )( 
01500             AkGameObjectID in_GameObjectID,     ///< Game Object identifier
01501             const AkSoundPosition & in_Position ///< Position to set; in_Position.Orientation must be normalized.
01502             );
01503 
01504         /// Sets multiple positions to a single game object.
01505         /// Setting multiple positions on a single game object is a way to simulate multiple emission sources while using the resources of only one voice.
01506         /// This can be used to simulate wall openings, area sounds, or multiple objects emitting the same sound in the same area.
01507         /// \aknote Calling <tt>AK::SoundEngine::SetMultiplePositions()</tt> with only one position is the same as calling <tt>AK::SoundEngine::SetPosition()</tt> \endaknote
01508         /// \return 
01509         /// - AK_Success when successful
01510         /// - AK_InvalidParameter if parameters are not valid.
01511         /// \sa 
01512         /// - \ref soundengine_3dpositions
01513         /// - \ref soundengine_3dpositions_multiplepos
01514         /// - \ref AK::SoundEngine::MultiPositionType
01515         AK_EXTERNAPIFUNC( AKRESULT, SetMultiplePositions )( 
01516             AkGameObjectID in_GameObjectID,                     ///< Game Object identifier.
01517             const AkSoundPosition * in_pPositions,              ///< Array of positions to apply.
01518             AkUInt16 in_NumPositions,                           ///< Number of positions specified in the provided array.
01519             MultiPositionType in_eMultiPositionType = MultiPositionType_MultiDirections ///< \ref AK::SoundEngine::MultiPositionType
01520             );
01521 
01522         /// Sets multiple positions to a single game object, with flexible assignment of input channels.
01523         /// Setting multiple positions on a single game object is a way to simulate multiple emission sources while using the resources of only one voice.
01524         /// This can be used to simulate wall openings, area sounds, or multiple objects emitting the same sound in the same area.
01525         /// \aknote Calling <tt>AK::SoundEngine::SetMultiplePositions()</tt> with only one position is the same as calling <tt>AK::SoundEngine::SetPosition()</tt> \endaknote
01526         /// \return 
01527         /// - AK_Success when successful
01528         /// - AK_InvalidParameter if parameters are not valid.
01529         /// \sa 
01530         /// - \ref soundengine_3dpositions
01531         /// - \ref soundengine_3dpositions_multiplepos
01532         /// - \ref AK::SoundEngine::MultiPositionType
01533         AK_EXTERNAPIFUNC( AKRESULT, SetMultiplePositions )( 
01534             AkGameObjectID in_GameObjectID,                     ///< Game Object identifier.
01535             const AkChannelEmitter * in_pPositions,         ///< Array of positions to apply, each using its own channel mask.
01536             AkUInt16 in_NumPositions,                           ///< Number of positions specified in the provided array.
01537             MultiPositionType in_eMultiPositionType = MultiPositionType_MultiDirections ///< \ref AK::SoundEngine::MultiPositionType
01538             );
01539 
01540         /// Sets the scaling factor of a Game Object.
01541         /// Modify the attenuation computations on this Game Object to simulate sounds with a larger or smaller area of effect.
01542         /// \return 
01543         /// - AK_Success when successful
01544         /// - AK_InvalidParameter if the scaling factor specified was 0 or negative.
01545         AK_EXTERNAPIFUNC( AKRESULT, SetScalingFactor )(
01546             AkGameObjectID in_GameObjectID,             ///< Game object identifier
01547             AkReal32 in_fAttenuationScalingFactor       ///< Scaling Factor, 1 means 100%, 0.5 means 50%, 2 means 200%, and so on.
01548             );
01549 
01550         //@}
01551 
01552         ////////////////////////////////////////////////////////////////////////
01553         /// @name Bank Management
01554         //@{
01555 
01556         /// Unload all currently loaded banks.
01557         /// It also internally calls ClearPreparedEvents() since at least one bank must have been loaded to allow preparing events.
01558         /// \return 
01559         /// - AK_Success if successful
01560         /// - AK_Fail if the sound engine was not correctly initialized or if there is not enough memory to handle the command
01561         /// \sa 
01562         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01563         /// - <tt>AK::SoundEngine::LoadBank()</tt>
01564         /// - \ref soundengine_banks
01565         AK_EXTERNAPIFUNC( AKRESULT, ClearBanks )();
01566 
01567         /// Sets the I/O settings of the bank load and prepare event processes.
01568         /// The sound engine uses default values unless explicitly set by calling this method.
01569         /// \warning This function must be called before loading banks.
01570         /// \return 
01571         /// - AK_Success if successful
01572         /// - AK_Fail if the sound engine was not correctly initialized
01573         /// - AK_InvalidParameter if some parameters are invalid
01574         /// \sa 
01575         /// - \ref soundengine_banks
01576         /// - \ref streamingdevicemanager
01577         AK_EXTERNAPIFUNC( AKRESULT, SetBankLoadIOSettings )(
01578             AkReal32            in_fThroughput,         ///< Average throughput of bank data streaming (bytes/ms) (the default value is AK_DEFAULT_BANK_THROUGHPUT)
01579             AkPriority          in_priority             ///< Priority of bank streaming (the default value is AK_DEFAULT_PRIORITY)
01580             );
01581 
01582 #ifdef AK_SUPPORT_WCHAR
01583         /// Load a bank synchronously (by Unicode string).\n
01584         /// The bank name is passed to the Stream Manager.
01585         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01586         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01587         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01588         /// The function returns when the request has been completely processed.
01589         /// \return 
01590         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01591         /// You may use this ID with UnloadBank().
01592         /// - AK_Success: Load or unload successful.
01593         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01594         /// - AK_BankReadError: I/O error.
01595         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01596         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01597         /// - AK_InvalidFile: File specified could not be opened.
01598         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01599         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01600         /// \remarks
01601         /// - The initialization bank must be loaded first.
01602         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01603         ///   initialization bank. If you need to load SoundBanks from a different project, you
01604         ///   must first unload ALL banks, including the initialization bank, then load the
01605         ///   initialization bank from the other project, and finally load banks from that project.
01606         /// - Codecs and plug-ins must be registered before loading banks that use them.
01607         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01608         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01609         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01610         /// posting the event will fail.
01611         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01612         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01613         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01614         /// your implementation of the Stream Manager, or in the Low-Level I/O module if you use the default Stream Manager's implementation.
01615         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01616         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01617         /// of the UnloadBank() function.
01618         /// \sa 
01619         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01620         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01621         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
01622         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01623         /// - \ref soundengine_banks
01624         /// - \ref integrating_elements_plugins
01625         /// - \ref streamingdevicemanager
01626         /// - \ref streamingmanager_lowlevel
01627         /// - \ref sdk_bank_training
01628         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01629             const wchar_t*      in_pszString,           ///< Name of the bank to load
01630             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01631             AkBankID &          out_bankID              ///< Returned bank ID
01632             );
01633 #endif //AK_SUPPORT_WCHAR
01634 
01635         /// Loads a bank synchronously.\n
01636         /// The bank name is passed to the Stream Manager.
01637         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01638         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01639         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01640         /// The function returns when the request has been completely processed.
01641         /// \return 
01642         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01643         /// You may use this ID with UnloadBank().
01644         /// - AK_Success: Load or unload successful.
01645         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01646         /// - AK_BankReadError: I/O error.
01647         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01648         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01649         /// - AK_InvalidFile: File specified could not be opened.
01650         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01651         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01652         /// \remarks
01653         /// - The initialization bank must be loaded first.
01654         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01655         ///   initialization bank. If you need to load SoundBanks from a different project, you
01656         ///   must first unload ALL banks, including the initialization bank, then load the
01657         ///   initialization bank from the other project, and finally load banks from that project.
01658         /// - Codecs and plug-ins must be registered before loading banks that use them.
01659         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01660         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01661         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01662         /// posting the event will fail.
01663         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01664         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01665         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01666         /// your implementation of the Stream Manager, or in the Low-Level I/O module if you use the default Stream Manager's implementation.
01667         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01668         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01669         /// of the UnloadBank() function.
01670         /// \sa 
01671         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01672         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01673         /// - <tt>AK::SoundEngine::GetIDFromString</tt>
01674         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01675         /// - \ref soundengine_banks
01676         /// - \ref integrating_elements_plugins
01677         /// - \ref streamingdevicemanager
01678         /// - \ref streamingmanager_lowlevel
01679         /// - \ref sdk_bank_training
01680         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01681             const char*         in_pszString,           ///< Name of the bank to load
01682             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01683             AkBankID &          out_bankID              ///< Returned bank ID
01684             );
01685 
01686         /// Loads a bank synchronously (by ID).\n
01687         /// \aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
01688         /// The bank ID is passed to the Stream Manager.
01689         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01690         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01691         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01692         /// The function returns when the request has been completely processed.
01693         /// \return 
01694         /// - AK_Success: Load or unload successful.
01695         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01696         /// - AK_BankReadError: I/O error.
01697         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01698         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01699         /// - AK_InvalidFile: File specified could not be opened.
01700         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01701         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01702         /// \remarks
01703         /// - The initialization bank must be loaded first.
01704         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01705         ///   initialization bank. If you need to load SoundBanks from a different project, you
01706         ///   must first unload ALL banks, including the initialization bank, then load the
01707         ///   initialization bank from the other project, and finally load banks from that project.
01708         /// - Codecs and plug-ins must be registered before loading banks that use them.
01709         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01710         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01711         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01712         /// posting the event will fail.
01713         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01714         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01715         /// of the UnloadBank function.
01716         /// \sa 
01717         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01718         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01719         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01720         /// - \ref soundengine_banks
01721         /// - \ref integrating_elements_plugins
01722         /// - \ref sdk_bank_training
01723         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01724             AkBankID            in_bankID,              ///< Bank ID of the bank to load
01725             AkMemPoolId         in_memPoolId            ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01726             );
01727 
01728         /// Loads a bank synchronously (from in-memory data, in-place).\n
01729         ///
01730         /// IMPORTANT: Banks loaded from memory with in-place data MUST be unloaded using the UnloadBank function
01731         /// providing the same memory pointer. Make sure you are using the correct UnloadBank(...) overload
01732         ///
01733         /// Use this overload when you want to manage I/O on your side. Load the bank file
01734         /// in a buffer and pass its address to the sound engine.
01735         /// In-memory loading is in-place: *** the memory must be valid until the bank is unloaded. ***
01736         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01737         /// The function returns when the request has been completely processed.
01738         /// \return 
01739         /// The bank ID, which is stored in the first few bytes of the bank file. You may use this 
01740         /// ID with UnloadBank().
01741         /// - AK_Success: Load or unload successful.
01742         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01743         /// - AK_BankReadError: I/O error.
01744         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01745         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01746         /// - AK_InvalidFile: File specified could not be opened.
01747         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01748         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01749         /// \remarks
01750         /// - The initialization bank must be loaded first.
01751         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01752         ///   initialization bank. If you need to load SoundBanks from a different project, you
01753         ///   must first unload ALL banks, including the initialization bank, then load the
01754         ///   initialization bank from the other project, and finally load banks from that project.
01755         /// - Codecs and plug-ins must be registered before loading banks that use them.
01756         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01757         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01758         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01759         /// posting the event will fail.
01760         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
01761         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
01762         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01763         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01764         /// of the UnloadBank function.
01765         /// - Avoid using this function for banks containing a lot of events or structure data.  
01766         ///   This data will be loaded in the Default Pool anyway thus duplicating memory (one copy in the Default Pool 
01767         ///   and one in the block you provided). For event/structure-only banks, prefer the other versions of LoadBank().
01768         /// \sa 
01769         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01770         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01771         /// - \ref soundengine_banks
01772         /// - \ref integrating_elements_plugins
01773         /// - \ref sdk_bank_training
01774         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01775             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is stored in sound engine, memory must remain valid)
01776             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
01777             AkBankID &          out_bankID              ///< Returned bank ID
01778             );
01779 
01780         /// Loads a bank synchronously (from in-memory data, out-of-place).\n
01781         ///
01782         /// NOTE: Banks loaded from in-memory with out-of-place data must be unloaded using the standard UnloadBank function
01783         /// (with no memory pointer). Make sure you are using the correct UnloadBank(...) overload
01784         ///
01785         /// Use this overload when you want to manage I/O on your side. Load the bank file
01786         /// in a buffer and pass its address to the sound engine, the media section of the bank will be copied into the 
01787         /// specified memory pool.  
01788         /// In-memory loading is out-of-place: the buffer can be release as soon as the function returns. The advantage of using this
01789         /// over the in-place version is that there is no duplication of bank structures.
01790         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01791         /// The function returns when the request has been completely processed.
01792         /// \return 
01793         /// The bank ID, which is stored in the first few bytes of the bank file. You may use this 
01794         /// ID with UnloadBank().
01795         /// - AK_Success: Load or unload successful.
01796         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01797         /// - AK_BankReadError: I/O error.
01798         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01799         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01800         /// - AK_InvalidFile: File specified could not be opened.
01801         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01802         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01803         /// \remarks
01804         /// - The initialization bank must be loaded first.
01805         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01806         ///   initialization bank. If you need to load SoundBanks from a different project, you
01807         ///   must first unload ALL banks, including the initialization bank, then load the
01808         ///   initialization bank from the other project, and finally load banks from that project.
01809         /// - Codecs and plug-ins must be registered before loading banks that use them.
01810         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01811         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01812         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01813         /// posting the event will fail.
01814         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
01815         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
01816         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01817         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01818         /// of the UnloadBank function.
01819         /// - Avoid using this function for banks containing a lot of events or structure data.  
01820         ///   This data will be loaded in the Default Pool anyway thus duplicating memory (one copy in the Default Pool 
01821         ///   and one in the block you provided). For event/structure-only banks, prefer the other versions of LoadBank().
01822         /// \sa 
01823         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01824         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01825         /// - \ref soundengine_banks
01826         /// - \ref integrating_elements_plugins
01827         /// - \ref sdk_bank_training
01828         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01829             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is not stored in sound engine, memory can be released after return)
01830             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
01831             AkMemPoolId         in_uPoolForBankMedia,   ///< Memory pool to copy the media section of the bank to (the pool is created if AK_DEFAULT_POOL_ID is passed).
01832             AkBankID &          out_bankID              ///< Returned bank ID
01833             );
01834 
01835         /// Synchronously decodes Vorbis-encoded and Opus-encoded (Software version) media in a SoundBank. The file should already be read in memory before the decode operation. The out_pDecodedBankPtr can then be used with variants of LoadBank that load from in-memory data.
01836         /// \n
01837         /// CPU usage, RAM size, storage size and Internet bandwidth must be accounted for when developing a game, especially when it is aimed at mobile platforms. The DecodeBank function makes it possible to decode media at load time instead of decoding them every time they are played.
01838         AK_EXTERNAPIFUNC( AKRESULT, DecodeBank )(
01839             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to decode (pointer is not stored in sound engine, memory can be released after return)
01840             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to decode
01841             AkMemPoolId         in_uPoolForDecodedBank, ///< Memory pool to allocate decoded bank into. Specify AK_INVALID_POOL_ID and out_pDecodedBankPtr=NULL to obtain decoded bank size without performing the decode operation. Pass AK_INVALID_POOL_ID and out_pDecodedBankPtr!=NULL to decode bank into specified pointer.
01842             void * &            out_pDecodedBankPtr,    ///< Decoded bank memory location.
01843             AkUInt32 &          out_uDecodedBankSize    ///< Decoded bank memory size.
01844             );
01845 
01846 #ifdef AK_SUPPORT_WCHAR
01847         /// Loads a bank asynchronously (by Unicode string).\n
01848         /// The bank name is passed to the Stream Manager.
01849         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01850         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01851         /// A bank load request will be posted to the Bank Manager consumer thread.
01852         /// The function returns immediately.
01853         /// \return 
01854         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01855         /// Use a callback to be notified when completed, and get the status of the request.
01856         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01857         /// You may use this ID with UnloadBank().
01858         /// \remarks
01859         /// - The initialization bank must be loaded first.
01860         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01861         ///   initialization bank. If you need to load SoundBanks from a different project, you
01862         ///   must first unload ALL banks, including the initialization bank, then load the
01863         ///   initialization bank from the other project, and finally load banks from that project.
01864         /// - Codecs and plug-ins must be registered before loading banks that use them.
01865         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01866         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01867         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01868         /// posting the event will fail.
01869         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01870         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01871         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01872         /// your implementation of the Stream Manager (<tt>AK::IAkStreamMgr::CreateStd()</tt>), or in the Low-Level I/O module 
01873         /// (<tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>) if you use the default Stream Manager's implementation.
01874         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01875         // as AkFileSystemFlags::pCustomParam.
01876         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01877         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01878         /// of the UnloadBank function.
01879         /// \sa 
01880         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01881         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01882         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01883         /// - AkBankCallbackFunc
01884         /// - \ref soundengine_banks
01885         /// - \ref integrating_elements_plugins
01886         /// - \ref streamingdevicemanager
01887         /// - \ref streamingmanager_lowlevel
01888         /// - \ref sdk_bank_training
01889         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01890             const wchar_t*      in_pszString,           ///< Name/path of the bank to load
01891             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01892             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01893             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01894             AkBankID &          out_bankID              ///< Returned bank ID
01895             );
01896 #endif //AK_SUPPORT_WCHAR
01897 
01898         /// Loads a bank asynchronously.\n
01899         /// The bank name is passed to the Stream Manager.
01900         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01901         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01902         /// A bank load request will be posted to the Bank Manager consumer thread.
01903         /// The function returns immediately.
01904         /// \return 
01905         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01906         /// Use a callback to be notified when completed, and get the status of the request.
01907         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01908         /// You may use this ID with UnloadBank().
01909         /// \remarks
01910         /// - The initialization bank must be loaded first.
01911         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01912         ///   initialization bank. If you need to load SoundBanks from a different project, you
01913         ///   must first unload ALL banks, including the initialization bank, then load the
01914         ///   initialization bank from the other project, and finally load banks from that project.
01915         /// - Codecs and plug-ins must be registered before loading banks that use them.
01916         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01917         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01918         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01919         /// posting the Event will fail.
01920         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01921         /// Therefore, \c in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01922         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01923         /// your implementation of the Stream Manager (<tt>AK::IAkStreamMgr::CreateStd()</tt>), or in the Low-Level I/O module 
01924         /// (<tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>) if you use the default Stream Manager's implementation.
01925         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01926         // as <tt>AkFileSystemFlags::pCustomParam</tt>.
01927         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01928         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01929         /// of the \c UnloadBank function.
01930         /// \sa 
01931         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01932         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01933         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01934         /// - AkBankCallbackFunc
01935         /// - \ref soundengine_banks
01936         /// - \ref integrating_elements_plugins
01937         /// - \ref streamingdevicemanager
01938         /// - \ref streamingmanager_lowlevel
01939         /// - \ref sdk_bank_training
01940         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01941             const char*         in_pszString,           ///< Name/path of the bank to load
01942             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01943             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01944             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01945             AkBankID &          out_bankID              ///< Returned bank ID
01946             );
01947 
01948         /// Loads a bank asynchronously (by ID).\n
01949         /// \aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
01950         /// The bank ID is passed to the Stream Manager.
01951         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01952         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01953         /// A bank load request will be posted to the Bank Manager consumer thread.
01954         /// The function returns immediately.
01955         /// \return 
01956         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01957         /// Use a callback to be notified when completed, and get the status of the request.
01958         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01959         /// You may use this ID with \c UnloadBank().
01960         /// \remarks
01961         /// - The initialization bank must be loaded first.
01962         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01963         ///   initialization bank. If you need to load SoundBanks from a different project, you
01964         ///   must first unload ALL banks, including the initialization bank, then load the
01965         ///   initialization bank from the other project, and finally load banks from that project.
01966         /// - Codecs and plug-ins must be registered before loading banks that use them.
01967         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01968         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01969         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01970         /// posting the event will fail.
01971         /// - The file path should be resolved in your implementation of the Stream Manager, or in the Low-Level I/O module if 
01972         /// you use the default Stream Manager's implementation. The ID overload of <tt>AK::IAkStreamMgr::CreateStd()</tt> and <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> are called.
01973         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01974         // as AkFileSystemFlags::pCustomParam.
01975         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01976         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01977         /// of the UnloadBank function.
01978         /// \sa 
01979         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01980         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01981         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01982         /// - AkBankCallbackFunc
01983         /// - \ref soundengine_banks
01984         /// - \ref integrating_elements_plugins
01985         /// - \ref sdk_bank_training
01986         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01987             AkBankID            in_bankID,              ///< Bank ID of the bank to load
01988             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01989             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01990             AkMemPoolId         in_memPoolId            ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01991             );
01992 
01993         /// Loads a bank asynchronously (from in-memory data, in-place).\n
01994         ///
01995         /// IMPORTANT: Banks loaded from memory with in-place data MUST be unloaded using the UnloadBank function
01996         /// providing the same memory pointer. Make sure you are using the correct UnloadBank(...) overload
01997         ///
01998         /// Use this overload when you want to manage I/O on your side. Load the bank file
01999         /// in a buffer and pass its address to the sound engine.
02000         /// In-memory loading is in-place: *** the memory must be valid until the bank is unloaded. ***
02001         /// A bank load request will be posted to the Bank Manager consumer thread.
02002         /// The function returns immediately.
02003         /// \return 
02004         /// AK_Success if the scheduling was successful, AK_Fail otherwise, or AK_InvalidParameter if memory alignment is not correct.
02005         /// Use a callback to be notified when completed, and get the status of the request.
02006         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
02007         /// You may use this ID with UnloadBank().
02008         /// \remarks
02009         /// - The initialization bank must be loaded first.
02010         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
02011         ///   initialization bank. If you need to load SoundBanks from a different project, you
02012         ///   must first unload ALL banks, including the initialization bank, then load the
02013         ///   initialization bank from the other project, and finally load banks from that project.
02014         /// - Codecs and plug-ins must be registered before loading banks that use them.
02015         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
02016         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
02017         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
02018         /// posting the event will fail.
02019         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
02020         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
02021         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
02022         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
02023         /// of the UnloadBank function.
02024         /// \sa 
02025         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
02026         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02027         /// - AkBankCallbackFunc
02028         /// - \ref soundengine_banks
02029         /// - \ref integrating_elements_plugins
02030         /// - \ref sdk_bank_training
02031         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
02032             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is stored in sound engine, memory must remain valid)
02033             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
02034             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02035             void *              in_pCookie,             ///< Callback cookie
02036             AkBankID &          out_bankID              ///< Returned bank ID
02037             );
02038 
02039         /// Loads a bank asynchronously (from in-memory data, out-of-place).\n
02040         ///
02041         /// NOTE: Banks loaded from in-memory with out-of-place data must be unloaded using the standard UnloadBank function
02042         /// (with no memory pointer). Make sure you are using the correct UnloadBank(...) overload
02043         ///
02044         /// Use this overload when you want to manage I/O on your side. Load the bank file
02045         /// in a buffer and pass its address to the sound engine, the media section of the bank will be copied into the 
02046         /// specified memory pool.  
02047         /// In-memory loading is out-of-place: the buffer can be released after the callback function is called. The advantage of using this
02048         /// over the in-place version is that there is no duplication of bank structures.
02049         /// A bank load request will be posted to the Bank Manager consumer thread.
02050         /// The function returns immediately.
02051         /// \return 
02052         /// AK_Success if the scheduling was successful, AK_Fail otherwise, or AK_InvalidParameter if memory alignment is not correct.
02053         /// Use a callback to be notified when completed, and get the status of the request.
02054         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
02055         /// You may use this ID with UnloadBank().
02056         /// \remarks
02057         /// - The initialization bank must be loaded first.
02058         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
02059         ///   initialization bank. If you need to load SoundBanks from a different project, you
02060         ///   must first unload ALL banks, including the initialization bank, then load the
02061         ///   initialization bank from the other project, and finally load banks from that project.
02062         /// - Codecs and plug-ins must be registered before loading banks that use them.
02063         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
02064         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
02065         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
02066         /// posting the event will fail.
02067         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
02068         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
02069         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
02070         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
02071         /// of the UnloadBank function.
02072         /// \sa 
02073         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
02074         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02075         /// - AkBankCallbackFunc
02076         /// - \ref soundengine_banks
02077         /// - \ref integrating_elements_plugins
02078         /// - \ref sdk_bank_training
02079         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
02080             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is not stored in sound engine, memory can be released after callback)
02081             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
02082             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02083             void *              in_pCookie,             ///< Callback cookie
02084             AkMemPoolId         in_uPoolForBankMedia,   ///< Memory pool to copy the media section of the bank to (the pool is created if AK_DEFAULT_POOL_ID is passed).
02085             AkBankID &          out_bankID              ///< Returned bank ID
02086             );
02087 
02088 #ifdef AK_SUPPORT_WCHAR
02089         /// Unloads a bank synchronously (by Unicode string).\n
02090         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02091         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02092         /// \remarks
02093         /// - If you provided a pool memory ID when loading this bank, it is returned as well. 
02094         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02095         /// - The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02096         /// then it calls the synchronous version of UnloadBank() by ID.
02097         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02098         /// not the name of the file (if you changed it), nor the full path of the file. 
02099         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02100         /// This means that streamed sounds or generated sounds will not be stopped.
02101         /// \sa 
02102         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02103         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02104         /// - \ref soundengine_banks
02105         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02106             const wchar_t*      in_pszString,           ///< Name of the bank to unload
02107             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02108             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02109             );
02110 #endif //AK_SUPPORT_WCHAR
02111 
02112         /// Unloads a bank synchronously.\n
02113         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02114         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02115         /// \remarks
02116         /// - If you provided a pool memory ID when loading this bank, it is returned as well. 
02117         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02118         /// - The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02119         /// then it calls the synchronous version of UnloadBank() by ID.
02120         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02121         /// not the name of the file (if you changed it), nor the full path of the file. 
02122         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02123         /// This means that streamed sounds or generated sounds will not be stopped.
02124         /// \sa 
02125         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02126         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02127         /// - \ref soundengine_banks
02128         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02129             const char*         in_pszString,           ///< Name of the bank to unload
02130             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02131             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02132             );
02133 
02134         /// Unloads a bank synchronously (by ID and memory pointer).\n
02135         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02136         /// \remarks
02137         /// If you provided a pool memory ID when loading this bank, it is returned as well. 
02138         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02139         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02140         /// This means that streamed sounds or generated sounds will not be stopped.
02141         /// \sa 
02142         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02143         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02144         /// - \ref soundengine_banks
02145         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02146             AkBankID            in_bankID,              ///< ID of the bank to unload
02147             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02148             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02149             );
02150 
02151 #ifdef AK_SUPPORT_WCHAR
02152         /// Unloads a bank asynchronously (by Unicode string).\n
02153         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02154         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02155         /// \remarks
02156         /// The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02157         /// then it calls the synchronous version of UnloadBank() by ID.
02158         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02159         /// not the name of the file (if you changed it), nor the full path of the file. 
02160         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02161         /// This means that streamed sounds or generated sounds will not be stopped.
02162         /// \sa 
02163         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02164         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02165         /// - AkBankCallbackFunc
02166         /// - \ref soundengine_banks
02167         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02168             const wchar_t*      in_pszString,           ///< Name of the bank to unload
02169             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02170             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02171             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02172             );
02173 #endif //AK_SUPPORT_WCHAR
02174 
02175         /// Unloads a bank asynchronously.\n
02176         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02177         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02178         /// \remarks
02179         /// The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02180         /// then it calls the synchronous version of UnloadBank() by ID.
02181         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02182         /// not the name of the file (if you changed it), nor the full path of the file. 
02183         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02184         /// This means that streamed sounds or generated sounds will not be stopped.
02185         /// \sa 
02186         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02187         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02188         /// - AkBankCallbackFunc
02189         /// - \ref soundengine_banks
02190         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02191             const char*         in_pszString,           ///< Name of the bank to unload
02192             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02193             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02194             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02195             );
02196 
02197         /// Unloads a bank asynchronously (by ID and memory pointer).\n
02198         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02199         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02200         /// \remarks
02201         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02202         /// This means that streamed sounds or generated sounds will not be stopped.
02203         /// \sa 
02204         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02205         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02206         /// - AkBankCallbackFunc
02207         /// - \ref soundengine_banks
02208         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02209             AkBankID            in_bankID,              ///< ID of the bank to unload
02210             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02211             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02212             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02213             );
02214 
02215         /// Cancels all Event callbacks associated with a specific callback cookie specified while loading Banks of preparing Events.\n
02216         /// \sa 
02217         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02218         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02219         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
02220         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02221         /// - AkBankCallbackFunc
02222         AK_EXTERNAPIFUNC( void, CancelBankCallbackCookie )( 
02223             void * in_pCookie                           ///< Callback cookie to be canceled
02224             );
02225 
02226         /// Preparation type.
02227         /// \sa
02228         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02229         /// - <tt>AK::SoundEngine::PrepareGameSyncs()</tt>
02230         /// - <tt>AK::SoundEngine::PrepareBank()</tt>
02231         enum PreparationType
02232         {
02233             Preparation_Load,   ///< \c PrepareEvent() will load required information to play the specified event.
02234             Preparation_Unload, ///< \c PrepareEvent() will unload required information to play the specified event.
02235             Preparation_LoadAndDecode ///< Vorbis media is decoded when loading, and an uncompressed PCM version is used for playback.
02236         };
02237 
02238         /// Parameter to be passed to <tt>AK::SoundEngine::PrepareBank()</tt>.
02239         /// Use AkBankContent_All to load both the media and structural content from the bank. 
02240         /// Use AkBankContent_StructureOnly to load only the structural content, including events, from the bank and then later use the PrepareEvent() functions to load media on demand from loose files on the disk.
02241         /// \sa 
02242         /// - <tt>AK::SoundEngine::PrepareBank()</tt>
02243         /// - \ref soundengine_banks_preparingbanks
02244         enum AkBankContent
02245         {
02246             AkBankContent_StructureOnly,    ///< Use AkBankContent_StructureOnly to load only the structural content, including Events, and then later use the PrepareEvent() functions to load media on demand from loose files on the disk.
02247             AkBankContent_All               ///< Use AkBankContent_All to load both the media and structural content.
02248         };
02249 
02250 #ifdef AK_SUPPORT_WCHAR
02251         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02252         /// the bank; but, as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02253         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02254         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02255         /// allowing using PrepareEvent() to load media on demand.  
02256         /// \sa 
02257         /// - \ref soundengine_banks_preparingbanks
02258         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02259         /// - <tt>AK::SoundEngine::PreparationType</tt>
02260         /// \remarks
02261         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02262         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02263         /// for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02264         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02265             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02266             const wchar_t*        in_pszString,                             ///< Name of the bank to Prepare/Unprepare.
02267             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02268             );
02269 #endif //AK_SUPPORT_WCHAR
02270 
02271         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02272         /// the bank; but, as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02273         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02274         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02275         /// allowing using PrepareEvent() to load media on demand.  
02276         /// \sa 
02277         /// - \ref soundengine_banks_preparingbanks
02278         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02279         /// - <tt>AK::SoundEngine::PreparationType</tt>
02280         /// \remarks
02281         /// \c PrepareBank(), when called with the flag \c AkBankContent_StructureOnly, requires additional calls to \c PrepareEvent() to load the media for each event. \c PrepareEvent(), however, is unable to 
02282         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02283         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses \c LoadBank() to load the bank in entirety.
02284         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02285             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02286             const char*           in_pszString,                             ///< Name of the bank to Prepare/Unprepare.
02287             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02288             );
02289 
02290         /// \n\aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
02291         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02292         /// the bank, but as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02293         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02294         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02295         /// allowing using PrepareEvent() to load media on demand.  
02296         /// \sa 
02297         /// - \ref soundengine_banks_preparingbanks
02298         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02299         /// - <tt>AK::SoundEngine::PreparationType</tt>
02300         /// \remarks
02301         /// \c PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02302         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02303         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02304         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02305             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02306             AkBankID            in_bankID,                                  ///< ID of the bank to Prepare/Unprepare.
02307             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02308             );
02309 
02310 #ifdef AK_SUPPORT_WCHAR
02311         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02312         /// the bank, but as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02313         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02314         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02315         /// allowing using PrepareEvent() to load media on demand.  
02316         /// \sa 
02317         /// - \ref soundengine_banks_preparingbanks
02318         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02319         /// - <tt>AK::SoundEngine::PreparationType</tt>
02320         /// \remarks
02321         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02322         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02323         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02324         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02325             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02326             const wchar_t*      in_pszString,                               ///< Name of the bank to Prepare/Unprepare.
02327             AkBankCallbackFunc  in_pfnBankCallback,                         ///< Callback function
02328             void *              in_pCookie,                                 ///< Callback cookie (reserved to user, passed to the callback function)
02329             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02330             );
02331 #endif //AK_SUPPORT_WCHAR
02332 
02333         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag \c AkBankContent_All is specified, \c PrepareBank() will load the media content from 
02334         /// the bank, but as opposed to \c LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using \c PrepareBank(), alone or in combination with PrepareEvent(), 
02335         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02336         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02337         /// allowing using PrepareEvent() to load media on demand.  
02338         /// \sa 
02339         /// - \ref soundengine_banks_preparingbanks
02340         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02341         /// - <tt>AK::SoundEngine::PreparationType()</tt>
02342         /// \remarks
02343         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02344         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02345         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02346         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02347             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02348             const char*         in_pszString,                               ///< Name of the bank to Prepare/Unprepare.
02349             AkBankCallbackFunc  in_pfnBankCallback,                         ///< Callback function
02350             void *              in_pCookie,                                 ///< Callback cookie (reserved to user, passed to the callback function)
02351             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02352             );
02353 
02354         /// \n\aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
02355         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, \c PrepareBank() will load the media content from 
02356         /// the bank, but as opposed to \c LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using \c PrepareBank(), alone or in combination with \c PrepareEvent(), 
02357         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02358         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02359         /// allowing using PrepareEvent() to load media on demand.  
02360         /// \sa 
02361         /// - \ref soundengine_banks_preparingbanks
02362         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02363         /// - <tt>AK::SoundEngine::PreparationType()</tt>
02364         /// \remarks
02365         /// \c PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. \c PrepareEvent(), however, is unable to 
02366         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02367         ///     for example, a game may have a tool mode that uses \c PrepareEvent() to load loose files on-demand and, also, a game mode that uses \c LoadBank() to load the bank in entirety.
02368         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02369             AK::SoundEngine::PreparationType        in_PreparationType,             ///< Preparation type ( Preparation_Load or Preparation_Unload )
02370             AkBankID            in_bankID,                      ///< ID of the bank to Prepare/Unprepare.
02371             AkBankCallbackFunc  in_pfnBankCallback,             ///< Callback function
02372             void *              in_pCookie,                     ///< Callback cookie (reserved to user, passed to the callback function)
02373             AK::SoundEngine::AkBankContent      in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02374             );
02375         
02376         /// Clear all previously prepared events.\n
02377         /// \return
02378         /// - AK_Success if successful.
02379         /// - AK_Fail if the sound engine was not correctly initialized or if there is not enough memory to handle the command.
02380         /// \remarks
02381         /// The function \c ClearBanks() also clears all prepared events.
02382         /// \sa
02383         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02384         /// - \c <tt>AK::SoundEngine::ClearBanks()</tt>
02385         AK_EXTERNAPIFUNC( AKRESULT, ClearPreparedEvents )();
02386 
02387 #ifdef AK_SUPPORT_WCHAR
02388         /// Prepares or unprepares Events synchronously (by Unicode string).\n
02389         /// The Events are identified by strings, and converted to IDs internally
02390         /// (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02391         /// Before invoking \c PrepareEvent(), use \c LoadBank() to explicitly load the SoundBank(s) 
02392         /// that contain the Events and structures. When a request is posted to the
02393         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02394         /// successfully post the specified Events and load the required loose media files. 
02395         /// \aknote Before version 2015.1, the required media files could be included
02396         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02397         /// however,\c  PrepareEvent() now only looks for loose media files.
02398         /// \endaknote
02399         /// The function returns when the request is completely processed.
02400         /// \return 
02401         /// - AK_Success: Prepare/un-prepare successful.
02402         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02403         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02404         /// - AK_BankReadError: I/O error.
02405         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02406         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02407         /// - AK_InvalidFile: File specified could not be opened.
02408         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02409         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02410         /// \remarks
02411         /// Whenever at least one event fails to be resolved, the actions performed for all 
02412         /// other events are cancelled.
02413         /// \sa
02414         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02415         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02416         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02417         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02418         /// - \ref soundengine_banks
02419         /// - \ref sdk_bank_training
02420         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02421             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02422             const wchar_t**     in_ppszString,          ///< Array of event names
02423             AkUInt32            in_uNumEvent            ///< Number of events in the array
02424             );
02425 #endif //AK_SUPPORT_WCHAR
02426 
02427         /// Prepares or unprepares events synchronously.\n
02428         /// The Events are identified by strings and converted to IDs internally
02429         /// (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02430         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02431         /// that contain the Events and structures. When a request is posted to the
02432         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02433         /// successfully post the specified Events and load the required loose media files. 
02434         /// \aknote Before version 2015.1, the required media files could be included
02435         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02436         /// however, PrepareEvent() now only looks for loose media files.
02437         /// \endaknote
02438         /// The function returns when the request is completely processed.
02439         /// \return 
02440         /// - AK_Success: Prepare/un-prepare successful.
02441         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02442         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02443         /// - AK_BankReadError: I/O error.
02444         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02445         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02446         /// - AK_InvalidFile: File specified could not be opened.
02447         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02448         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02449         /// \remarks
02450         /// Whenever at least one event fails to be resolved, the actions performed for all 
02451         /// other events are cancelled.
02452         /// \sa
02453         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02454         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02455         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02456         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02457         /// - \ref soundengine_banks
02458         /// - \ref sdk_bank_training
02459         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02460             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02461             const char**        in_ppszString,          ///< Array of event names
02462             AkUInt32            in_uNumEvent            ///< Number of events in the array
02463             );
02464 
02465         /// Prepares or unprepares events synchronously (by ID).
02466         /// The Events are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02467         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02468         /// that contain the Events and structures. When a request is posted to the
02469         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02470         /// successfully post the specified Events and load the required loose media files. 
02471         /// \aknote Before version 2015.1, the required media files could be included
02472         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02473         /// however, PrepareEvent() now only looks for loose media files.
02474         /// \endaknote
02475         /// The function returns when the request is completely processed.
02476         /// \return 
02477         /// - AK_Success: Prepare/un-prepare successful.
02478         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02479         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02480         /// - AK_BankReadError: I/O error.
02481         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02482         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02483         /// - AK_InvalidFile: File specified could not be opened.
02484         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02485         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02486         /// \remarks
02487         /// Whenever at least one event fails to be resolved, the actions performed for all 
02488         /// other events are cancelled.
02489         /// \sa
02490         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02491         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02492         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02493         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02494         /// - \ref soundengine_banks
02495         /// - \ref sdk_bank_training
02496         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02497             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02498             AkUniqueID*         in_pEventID,            ///< Array of event IDs
02499             AkUInt32            in_uNumEvent            ///< Number of event IDs in the array
02500             );
02501 
02502 #ifdef AK_SUPPORT_WCHAR
02503         /// Prepares or unprepares an event asynchronously (by Unicode string).
02504         /// The Events are identified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02505         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02506         /// that contain the Events and structures. When a request is posted to the
02507         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02508         /// successfully post the specified Events and load the required loose media files. 
02509         /// \aknote Before version 2015.1, the required media files could be included
02510         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02511         /// however, \c PrepareEvent() now only looks for loose media files.
02512         /// \endaknote
02513         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02514         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02515         /// \remarks
02516         /// Whenever at least one Event fails to be resolved, the actions performed for all 
02517         /// other Events are cancelled.
02518         /// \sa
02519         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02520         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02521         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02522         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02523         /// - AkBankCallbackFunc
02524         /// - \ref soundengine_banks
02525         /// - \ref sdk_bank_training
02526         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02527             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02528             const wchar_t**     in_ppszString,          ///< Array of event names
02529             AkUInt32            in_uNumEvent,           ///< Number of events in the array
02530             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02531             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02532             );
02533 #endif //AK_SUPPORT_WCHAR
02534 
02535         /// Prepares or unprepares an event asynchronously.
02536         /// The Events are identified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02537         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02538         /// that contain the Events and structures. When a request is posted to the
02539         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02540         /// successfully post the specified Events and load the required loose media files. 
02541         /// \aknote Before version 2015.1, the required media files could be included
02542         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02543         /// however, PrepareEvent() now only looks for loose media files.
02544         /// \endaknote
02545         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02546         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02547         /// \remarks
02548         /// Whenever at least one event fails to be resolved, the actions performed for all 
02549         /// other events are cancelled.
02550         /// \sa
02551         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02552         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02553         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02554         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02555         /// - AkBankCallbackFunc
02556         /// - \ref soundengine_banks
02557         /// - \ref sdk_bank_training
02558         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02559             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02560             const char**        in_ppszString,          ///< Array of event names 
02561             AkUInt32            in_uNumEvent,           ///< Number of events in the array
02562             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02563             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02564             );
02565 
02566         /// Prepares or unprepares events asynchronously (by ID).\n
02567         /// The Events are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02568         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02569         /// that contain the Events and structures. When a request is posted to the
02570         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02571         /// successfully post the specified Events and load the required loose media files. 
02572         /// \aknote Before version 2015.1, the required media files could be included
02573         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02574         /// however, PrepareEvent() now only looks for loose media files.
02575         /// \endaknote
02576         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02577         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02578         /// \remarks
02579         /// Whenever at least one event fails to be resolved, the actions performed for all 
02580         /// other events are cancelled.
02581         /// \sa
02582         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02583         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02584         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02585         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02586         /// - AkBankCallbackFunc
02587         /// - \ref soundengine_banks
02588         /// - \ref sdk_bank_training
02589         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02590             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02591             AkUniqueID*         in_pEventID,            ///< Array of event IDs
02592             AkUInt32            in_uNumEvent,           ///< Number of event IDs in the array
02593             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02594             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02595             );
02596 
02597         /// Indicates the location of a specific Media ID in memory
02598         /// The sources are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02599         /// \return AK_Success if operation was successful, AK_InvalidParameter if in_pSourceSettings is invalid, and AK_Fail otherwise.
02600         AK_EXTERNAPIFUNC( AKRESULT, SetMedia )( 
02601             AkSourceSettings *  in_pSourceSettings,     ///< Array of Source Settings
02602             AkUInt32            in_uNumSourceSettings   ///< Number of Source Settings in the array
02603             );
02604 
02605         /// Removes the specified source from the list of loaded media.
02606         /// The sources are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02607         /// \return AK_Success if operation was successful, AK_InvalidParameter if in_pSourceSettings is invalid, and AK_Fail otherwise.
02608         AK_EXTERNAPIFUNC( AKRESULT, UnsetMedia )( 
02609             AkSourceSettings *  in_pSourceSettings,     ///< Array of Source Settings
02610             AkUInt32            in_uNumSourceSettings   ///< Number of Source Settings in the array
02611             );
02612 
02613 #ifdef AK_SUPPORT_WCHAR
02614         /// Prepares or unprepares game syncs synchronously (by Unicode string).\n
02615         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02616         /// The game syncs definitions must already exist in the sound engine by having
02617         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02618         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02619         /// dependencies needed to successfully set this game sync group to one of the
02620         /// game sync values specified, and load the required banks, if applicable. 
02621         /// The function returns when the request has been completely processed. 
02622         /// \return 
02623         /// - AK_Success: Prepare/un-prepare successful.
02624         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02625         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02626         /// - AK_BankReadError: I/O error.
02627         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02628         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02629         /// - AK_InvalidFile: File specified could not be opened.
02630         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02631         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02632         /// \remarks
02633         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02634         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02635         /// so you never need to call this function.
02636         /// \sa 
02637         /// - \c <tt>AK::SoundEngine::GetIDFromString()</tt>
02638         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02639         /// - \c <tt>AK::SoundEngine::LoadBank()</tt>
02640         /// - \c AkInitSettings
02641         /// - \ref soundengine_banks
02642         /// - \ref sdk_bank_training
02643         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02644             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02645             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02646             const wchar_t*  in_pszGroupName,            ///< The State Group Name or the Switch Group Name.
02647             const wchar_t** in_ppszGameSyncName,        ///< The specific ID of the state to either support or not support.
02648             AkUInt32        in_uNumGameSyncs            ///< The number of game sync in the string array.
02649             );
02650 #endif //AK_SUPPORT_WCHAR
02651 
02652         /// Prepares or unprepares game syncs synchronously.\n
02653         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02654         /// The game syncs definitions must already exist in the sound engine by having
02655         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02656         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02657         /// dependencies needed to successfully set this game sync group to one of the
02658         /// game sync values specified, and load the required banks, if applicable. 
02659         /// The function returns when the request has been completely processed. 
02660         /// \return 
02661         /// - AK_Success: Prepare/un-prepare successful.
02662         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02663         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02664         /// - AK_BankReadError: I/O error.
02665         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02666         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02667         /// - AK_InvalidFile: File specified could not be opened.
02668         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02669         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02670         /// \remarks
02671         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02672         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02673         /// so you never need to call this function.
02674         /// \sa 
02675         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02676         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02677         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02678         /// - AkInitSettings
02679         /// - \ref soundengine_banks
02680         /// - \ref sdk_bank_training
02681         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02682             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02683             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02684             const char*     in_pszGroupName,            ///< The State Group Name or the Switch Group Name.
02685             const char**    in_ppszGameSyncName,        ///< The specific ID of the state to either support or not support.
02686             AkUInt32        in_uNumGameSyncs            ///< The number of game sync in the string array.
02687             );
02688 
02689         /// Prepares or unprepares game syncs synchronously (by ID).\n
02690         /// The group and game syncs are specified by ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02691         /// The game syncs definitions must already exist in the sound engine by having
02692         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02693         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02694         /// dependencies needed to successfully set this game sync group to one of the
02695         /// game sync values specified, and load the required banks, if applicable. 
02696         /// The function returns when the request has been completely processed. 
02697         /// \return 
02698         /// - AK_Success: Prepare/un-prepare successful.
02699         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02700         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02701         /// - AK_BankReadError: I/O error.
02702         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02703         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02704         /// - AK_InvalidFile: File specified could not be opened.
02705         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02706         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02707         /// \remarks
02708         /// You need to call \c PrepareGameSyncs() if the sound engine was initialized with \c AkInitSettings::bEnableGameSyncPreparation 
02709         /// set to \c true. When set to \c false, the sound engine automatically prepares all game syncs when preparing Events,
02710         /// so you never need to call this function.
02711         /// \sa 
02712         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02713         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02714         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02715         /// - AkInitSettings
02716         /// - \ref soundengine_banks
02717         /// - \ref sdk_bank_training
02718         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02719             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02720             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02721             AkUInt32        in_GroupID,                 ///< The State Group ID or the Switch Group ID.
02722             AkUInt32*       in_paGameSyncID,            ///< Array of ID of the game syncs to either support or not support.
02723             AkUInt32        in_uNumGameSyncs            ///< The number of game sync ID in the array.
02724             );
02725 
02726 #ifdef AK_SUPPORT_WCHAR
02727         /// Prepares or unprepares game syncs asynchronously (by Unicode string).\n
02728         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02729         /// The game syncs definitions must already exist in the sound engine by having
02730         /// explicitly loaded the bank(s) that contain them (with <tt>LoadBank()</tt>).
02731         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02732         /// dependencies needed to successfully set this game sync group to one of the
02733         /// game sync values specified, and load the required banks, if applicable. 
02734         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02735         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02736         /// \remarks
02737         /// You need to call \c PrepareGameSyncs() if the sound engine was initialized with \c AkInitSettings::bEnableGameSyncPreparation 
02738         /// set to \c true. When set to \c false, the sound engine automatically prepares all game syncs when preparing Events,
02739         /// so you never need to call this function.
02740         /// \sa 
02741         /// - \c <tt>AK::SoundEngine::GetIDFromString()</tt>
02742         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02743         /// - \c <tt>AK::SoundEngine::LoadBank()</tt>
02744         /// - \c AkInitSettings
02745         /// - \c AkBankCallbackFunc
02746         /// - \ref soundengine_banks
02747         /// - \ref sdk_bank_training
02748         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02749             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02750             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02751             const wchar_t*      in_pszGroupName,        ///< The State Group Name or the Switch Group Name.
02752             const wchar_t**     in_ppszGameSyncName,    ///< The specific ID of the state to either support or not support.
02753             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync in the string array.
02754             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02755             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02756             );
02757 #endif //AK_SUPPORT_WCHAR
02758 
02759         /// Prepares or unprepares game syncs asynchronously.\n
02760         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02761         /// The game syncs definitions must already exist in the sound engine by having
02762         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02763         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02764         /// dependencies needed to successfully set this game sync group to one of the
02765         /// game sync values specified, and load the required banks, if applicable. 
02766         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02767         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02768         /// \remarks
02769         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02770         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02771         /// so you never need to call this function.
02772         /// \sa 
02773         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02774         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02775         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02776         /// - AkInitSettings
02777         /// - AkBankCallbackFunc
02778         /// - \ref soundengine_banks
02779         /// - \ref sdk_bank_training
02780         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02781             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02782             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02783             const char*         in_pszGroupName,        ///< The State Group Name or the Switch Group Name.
02784             const char**        in_ppszGameSyncName,    ///< The specific ID of the state to either support or not support.
02785             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync in the string array.
02786             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02787             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02788             );
02789 
02790         /// Prepares or un-prepare game syncs asynchronously (by ID).\n
02791         /// The group and game syncs are specified by ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02792         /// The game syncs definitions must already exist in the sound engine by having
02793         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02794         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02795         /// dependencies needed to successfully set this game sync group to one of the
02796         /// game sync values specified, and load the required banks, if applicable. 
02797         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02798         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02799         /// \remarks
02800         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02801         /// set to true. When set to false, the sound engine automatically prepares all Game Syncs when preparing Events,
02802         /// so you never need to call this function.
02803         /// \sa 
02804         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02805         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02806         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02807         /// - AkInitSettings
02808         /// - AkBankCallbackFunc
02809         /// - \ref soundengine_banks
02810         /// - \ref sdk_bank_training
02811         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02812             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02813             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02814             AkUInt32            in_GroupID,             ///< The State Group ID or the Switch Group ID.
02815             AkUInt32*           in_paGameSyncID,        ///< Array of ID of the Game Syncs to either support or not support.
02816             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync ID in the array.
02817             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02818             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02819             );
02820 
02821         //@}
02822 
02823 
02824         ////////////////////////////////////////////////////////////////////////
02825         /// @name Listeners
02826         //@{
02827 
02828         /// Sets a game object's associated listeners.
02829         /// All listeners that have previously been added via AddListener or set via SetListeners will be removed and replaced with the listeners in the array in_pListenerGameObjs.
02830         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02831         /// \return Always returns AK_Success
02832         /// \sa 
02833         /// - <tt>AK::SoundEngine::AddListener</tt>
02834         /// - <tt>AK::SoundEngine::RemoveListener</tt>
02835         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02836         /// - \ref soundengine_listeners
02837         AK_EXTERNAPIFUNC( AKRESULT, SetListeners )(
02838             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.  Must have been previously registered via RegisterGameObj.
02839             const AkGameObjectID* in_pListenerGameObjs, ///< Array of listener game object IDs that will be activated for in_emitterGameObj. 
02840             AkUInt32 in_uNumListeners                   ///< Length of array
02841             );
02842 
02843         /// Add a single listener to a game object's set of associated listeners.
02844         /// Any listeners that have previously been added or set via AddListener or SetListeners will remain as listeners and in_listenerGameObj will be added as an additional listener.
02845         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02846         /// \sa 
02847         /// - <tt>AK::SoundEngine::SetListeners</tt>
02848         /// - <tt>AK::SoundEngine::RemoveListener</tt>
02849         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02850         /// - \ref soundengine_listeners
02851         AK_EXTERNAPIFUNC(AKRESULT, AddListener)(
02852             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.  Must have been previously registered via RegisterGameObj.
02853             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be activated for in_emitterGameObj. 
02854             );
02855 
02856         /// Remove a single listener from a game object's set of active listeners.
02857         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02858         /// \sa 
02859         /// - <tt>AK::SoundEngine::SetListeners</tt>
02860         /// - <tt>AK::SoundEngine::AddListener</tt>
02861         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02862         /// - \ref soundengine_listeners
02863         AK_EXTERNAPIFUNC(AKRESULT, RemoveListener)(
02864             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.
02865             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be deactivated for in_emitterGameObj. Game objects must have been previously registered.
02866             );
02867 
02868         /// Sets the default set of associated listeners for game objects that have not explicitly overridden their listener sets.  Upon registration, all game objects reference the default listener set, until
02869         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02870         /// All default listeners that have previously been added via AddDefaultListener or set via SetDefaultListeners will be removed and replaced with the listeners in the array in_pListenerGameObjs.
02871         /// \return Always returns AK_Success
02872         /// \sa 
02873         /// - \ref soundengine_listeners
02874         AK_EXTERNAPIFUNC(AKRESULT, SetDefaultListeners)(
02875             const AkGameObjectID* in_pListenerObjs, ///< Array of listener game object IDs that will be activated for subsequent registrations. Game objects must have been previously registered.
02876             AkUInt32 in_uNumListeners               ///< Length of array
02877             );
02878 
02879         /// Add a single listener to the default set of listeners.  Upon registration, all game objects reference the default listener set, until
02880         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02881         /// \sa 
02882         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02883         /// - <tt>AK::SoundEngine::RemoveDefaultListener</tt>
02884         /// - \ref soundengine_listeners
02885         AK_EXTERNAPIFUNC(AKRESULT, AddDefaultListener)(
02886             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be added to the default set of listeners.
02887             );
02888 
02889         /// Remove a single listener from the default set of listeners.  Upon registration, all game objects reference the default listener set, until
02890         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02891         /// \sa 
02892         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02893         /// - <tt>AK::SoundEngine::AddDefaultListener</tt>
02894         /// - \ref soundengine_listeners
02895         AK_EXTERNAPIFUNC(AKRESULT, RemoveDefaultListener)(
02896             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be removed from the default set of listeners.
02897             );
02898 
02899         /// Resets the listener associations to the default listener(s), as set by <tt>SetDefaultListeners</tt>. This will also reset per-listener gains that have been set using <tt>SetGameObjectOutputBusVolume</tt>.
02900         /// \return Always returns AK_Success
02901         /// \sa 
02902         /// - <tt>AK::SoundEngine::SetListeners</tt>
02903         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02904         /// - <tt>AK::SoundEngine::SetGameObjectOutputBusVolume</tt>
02905         /// - \ref soundengine_listeners
02906         AK_EXTERNAPIFUNC(AKRESULT, ResetListenersToDefault)(
02907             AkGameObjectID in_emitterGameObj    ///< Emitter game object.
02908             );
02909 
02910         /// Sets a listener's spatialization parameters. This lets you define listener-specific 
02911         /// volume offsets for each audio channel.
02912         /// If \c in_bSpatialized is false, only \c in_pVolumeOffsets is used for this listener (3D positions 
02913         /// have no effect on the speaker distribution). Otherwise, \c in_pVolumeOffsets is added to the speaker
02914         /// distribution computed for this listener.
02915         /// Use helper functions of \c AK::SpeakerVolumes to manipulate the vector of volume offsets in_pVolumeOffsets.
02916         /// 
02917         /// \remarks
02918         /// - If a sound is mixed into a bus that has a different speaker configuration than in_channelConfig,
02919         /// standard up/downmix rules apply.
02920         /// - Sounds with 3D Spatialization set to None will not be affected by these parameters.
02921         /// \return \c AK_Success if message was successfully posted to sound engine queue, \c AK_Fail otherwise.
02922         /// \sa 
02923         /// - \ref soundengine_listeners_spatial
02924         AK_EXTERNAPIFUNC( AKRESULT, SetListenerSpatialization )(
02925             AkGameObjectID in_uListenerID,              ///< Listener game object ID
02926             bool in_bSpatialized,                       ///< Spatialization toggle (True : enable spatialization, False : disable spatialization)
02927             AkChannelConfig in_channelConfig,           ///< Channel configuration associated with volumes in_pVolumeOffsets. Ignored if in_pVolumeOffsets is NULL.
02928             AK::SpeakerVolumes::VectorPtr in_pVolumeOffsets = NULL  ///< Per-speaker volume offset, in dB. See AkSpeakerVolumes.h for how to manipulate this vector.
02929             );
02930 
02931         //@}
02932 
02933 
02934         ////////////////////////////////////////////////////////////////////////
02935         /// @name Game Syncs
02936         //@{
02937 
02938         /// Sets the value of a real-time parameter control (by ID).
02939         /// With this function, you may set a game parameter value with global scope or with game object scope. 
02940         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with a global scope are applied to all 
02941         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02942         /// To set a game parameter value with global scope, pass \c AK_INVALID_GAME_OBJECT as the game object. 
02943         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02944         /// value for \c in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02945         /// according to the interpolation curve. If you call \c <tt><tt>SetRTPCValue()</tt></tt> with <tt>in_uValueChangeDuration = 0</tt> in the 
02946         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02947         /// function at every game frame, you should not use \c in_uValueChangeDuration, as it would have no effect and it is less efficient.
02948         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02949         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
02950         /// \return Always \c AK_Success
02951         /// \sa 
02952         /// - \ref soundengine_rtpc
02953         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02954         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
02955             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
02956             AkRtpcValue in_value,                                   ///< Value to set
02957             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
02958             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
02959             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
02960             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.
02961             );
02962 
02963 #ifdef AK_SUPPORT_WCHAR
02964         /// Sets the value of a real-time parameter control (by Unicode string name).
02965         /// With this function, you may set a game parameter value to global scope or to game object scope. 
02966         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with global scope are applied to all 
02967         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02968         /// To set a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
02969         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02970         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02971         /// according to the interpolation curve. If you call SetRTPCValue() with in_uValueChangeDuration = 0 in the 
02972         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02973         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
02974         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02975         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
02976         /// \return 
02977         /// - AK_Success if successful
02978         /// - AK_IDNotFound if in_pszRtpcName is NULL.
02979         /// \aknote Strings are case-insensitive. \endaknote
02980         /// \sa 
02981         /// - \ref soundengine_rtpc
02982         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
02983             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
02984             AkRtpcValue in_value,                                   ///< Value to set
02985             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
02986             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
02987             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
02988             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.
02989             );
02990 #endif //AK_SUPPORT_WCHAR
02991 
02992         /// Sets the value of a real-time parameter control.
02993         /// With this function, you may set a game parameter value with global scope or with game object scope. 
02994         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with global scope are applied to all 
02995         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02996         /// To set a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
02997         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02998         /// value for \c in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02999         /// according to the interpolation curve. If you call SetRTPCValue() with in_uValueChangeDuration = 0 in the 
03000         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03001         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03002         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03003         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03004         /// \return 
03005         /// - AK_Success if successful
03006         /// - AK_IDNotFound if in_pszRtpcName is NULL.
03007         /// \aknote Strings are case-insensitive. \endaknote
03008         /// \sa 
03009         /// - \ref soundengine_rtpc
03010         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
03011             const char* in_pszRtpcName,                             ///< Name of the game parameter
03012             AkRtpcValue in_value,                                   ///< Value to set
03013             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03014             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03015             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03016             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.
03017             );
03018 
03019         /// Sets the value of a real-time parameter control (by ID).
03020         /// With this function, you may set a game parameter value on playing id scope. 
03021         /// Playing id scope supersedes both game object scope and global scope. 
03022         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
03023         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03024         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
03025         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03026         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03027         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03028         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03029         /// \return Always AK_Success
03030         /// \sa 
03031         /// - \ref soundengine_rtpc
03032         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03033         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03034             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
03035             AkRtpcValue in_value,                                   ///< Value to set
03036             AkPlayingID in_playingID,                               ///< Associated playing ID
03037             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03038             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03039             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 don't want the values to interpolate.
03040             );
03041 
03042 #ifdef AK_SUPPORT_WCHAR
03043         /// Sets the value of a real-time parameter control (by Unicode string name).
03044         /// With this function, you may set a game parameter value on playing ID scope. 
03045         /// Playing id scope supersedes both game object scope and global scope. 
03046         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
03047         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03048         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
03049         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03050         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03051         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03052         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03053         /// \return Always AK_Success
03054         /// \sa 
03055         /// - \ref soundengine_rtpc
03056         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03057         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03058             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
03059             AkRtpcValue in_value,                                   ///< Value to set
03060             AkPlayingID in_playingID,                               ///< Associated playing ID
03061             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03062             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03063             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 don't want the values to interpolate.
03064             );
03065 #endif //AK_SUPPORT_WCHAR
03066         
03067         /// Sets the value of a real-time parameter control (by string name).
03068         /// With this function, you may set a game parameter value on playing id scope. 
03069         /// Playing id scope supersedes both game object scope and global scope. 
03070         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
03071         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03072         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
03073         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03074         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03075         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03076         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03077         /// \return Always AK_Success
03078         /// \sa 
03079         /// - \ref soundengine_rtpc
03080         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03081         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03082             const char* in_pszRtpcName,                             ///< Name of the game parameter
03083             AkRtpcValue in_value,                                   ///< Value to set
03084             AkPlayingID in_playingID,                               ///< Associated playing ID
03085             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03086             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03087             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.
03088             );
03089 
03090         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03091         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03092         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03093         /// game objects that were not overridden with a value with game object scope.
03094         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03095         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03096         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03097         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03098         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03099         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03100         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03101         /// \return Always AK_Success
03102         /// \sa 
03103         /// - \ref soundengine_rtpc
03104         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03105         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03106         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03107             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
03108             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03109             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03110             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03111             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.
03112             );
03113 
03114 #ifdef AK_SUPPORT_WCHAR
03115         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03116         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03117         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03118         /// game objects that were not overridden with a value with game object scope.
03119         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03120         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03121         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03122         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03123         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03124         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03125         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03126         /// \return 
03127         /// - AK_Success if successful
03128         /// - AK_IDNotFound if in_pszParamName is NULL.
03129         /// \aknote Strings are case-insensitive. \endaknote
03130         /// \sa 
03131         /// - \ref soundengine_rtpc
03132         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03133         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03134             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
03135             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03136             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03137             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03138             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.
03139             );
03140 #endif //AK_SUPPORT_WCHAR
03141 
03142         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03143         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03144         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03145         /// game objects that were not overridden with a value with game object scope.
03146         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03147         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03148         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03149         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03150         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03151         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03152         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03153         /// \return 
03154         /// - AK_Success if successful
03155         /// - AK_IDNotFound if in_pszParamName is NULL.
03156         /// \aknote Strings are case-insensitive. \endaknote
03157         /// \sa 
03158         /// - \ref soundengine_rtpc
03159         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03160         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03161             const char* in_pszRtpcName,                             ///< Name of the game parameter
03162             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03163             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03164             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03165             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.
03166             );
03167 
03168         /// Sets the State of a Switch Group (by IDs).
03169         /// \return Always returns AK_Success
03170         /// \sa 
03171         /// - \ref soundengine_switch
03172         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03173         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03174             AkSwitchGroupID in_switchGroup,             ///< ID of the Switch Group
03175             AkSwitchStateID in_switchState,             ///< ID of the Switch
03176             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03177             );
03178 
03179 #ifdef AK_SUPPORT_WCHAR
03180         /// Sets the State of a Switch Group (by Unicode string names).
03181         /// \return 
03182         /// - AK_Success if successful
03183         /// - AK_IDNotFound if the switch or Switch Group name was not resolved to an existing ID\n
03184         /// Make sure that the banks were generated with the "include string" option.
03185         /// \aknote Strings are case-insensitive. \endaknote
03186         /// \sa 
03187         /// - \ref soundengine_switch
03188         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03189             const wchar_t* in_pszSwitchGroup,           ///< Name of the Switch Group
03190             const wchar_t* in_pszSwitchState,           ///< Name of the Switch
03191             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03192             );
03193 #endif //AK_SUPPORT_WCHAR
03194 
03195         /// Sets the state of a Switch Group.
03196         /// \return 
03197         /// - AK_Success if successful
03198         /// - AK_IDNotFound if the switch or Switch Group name was not resolved to an existing ID\n
03199         /// Make sure that the banks were generated with the "include string" option.
03200         /// \aknote Strings are case-insensitive. \endaknote
03201         /// \sa 
03202         /// - \ref soundengine_switch
03203         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03204             const char* in_pszSwitchGroup,              ///< Name of the Switch Group
03205             const char* in_pszSwitchState,              ///< Name of the Switch
03206             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03207             );
03208 
03209         /// Post the specified trigger (by IDs).
03210         /// \return Always returns AK_Success
03211         /// \sa 
03212         /// - \ref soundengine_triggers
03213         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03214         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03215             AkTriggerID     in_triggerID,               ///< ID of the trigger
03216             AkGameObjectID  in_gameObjectID             ///< Associated game object ID
03217             );
03218 
03219 #ifdef AK_SUPPORT_WCHAR
03220         /// Posts the specified trigger (by Unicode string name).
03221         /// \return 
03222         /// - AK_Success if successful
03223         /// - AK_IDNotFound if the trigger name was not resolved to an existing ID\n
03224         /// Make sure that the banks were generated with the "include string" option.
03225         /// \aknote Strings are case-insensitive. \endaknote
03226         /// \sa 
03227         /// - \ref soundengine_triggers
03228         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03229             const wchar_t* in_pszTrigger,               ///< Name of the trigger
03230             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03231             );
03232 #endif //AK_SUPPORT_WCHAR
03233 
03234         /// Posts the specified trigger.
03235         /// \return 
03236         /// - AK_Success if successful
03237         /// - AK_IDNotFound if the trigger name was not resolved to an existing ID\n
03238         /// Make sure that the banks were generated with the "include string" option.
03239         /// \aknote Strings are case-insensitive. \endaknote
03240         /// \sa 
03241         /// - \ref soundengine_triggers
03242         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03243             const char* in_pszTrigger,                  ///< Name of the trigger
03244             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03245             );
03246 
03247         /// Sets the state of a State Group (by IDs).
03248         /// \return Always returns AK_Success
03249         /// \sa 
03250         /// - \ref soundengine_states
03251         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03252         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03253             AkStateGroupID in_stateGroup,               ///< ID of the State Group
03254             AkStateID in_state                          ///< ID of the state
03255             );
03256 
03257 #ifdef AK_SUPPORT_WCHAR
03258         /// Sets the state of a State Group (by Unicode string names).
03259         /// \return 
03260         /// - AK_Success if successful
03261         /// - AK_IDNotFound if the state or State Group name was not resolved to an existing ID\n
03262         /// Make sure that the banks were generated with the "include string" option.
03263         /// \aknote Strings are case-insensitive. \endaknote
03264         /// \sa 
03265         /// - \ref soundengine_states
03266         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03267         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03268             const wchar_t* in_pszStateGroup,                ///< Name of the State Group
03269             const wchar_t* in_pszState                      ///< Name of the state
03270             );
03271 #endif //AK_SUPPORT_WCHAR
03272 
03273         /// Sets the state of a State Group.
03274         /// \return 
03275         /// - AK_Success if successful
03276         /// - AK_IDNotFound if the state or State Group name was not resolved to an existing ID\n
03277         /// Make sure that the banks were generated with the "include string" option.
03278         /// \aknote Strings are case-insensitive. \endaknote
03279         /// \sa 
03280         /// - \ref soundengine_states
03281         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03282         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03283             const char* in_pszStateGroup,                   ///< Name of the State Group
03284             const char* in_pszState                         ///< Name of the state
03285             );
03286 
03287         //@}
03288 
03289         ////////////////////////////////////////////////////////////////////////
03290         /// @name Environments
03291         //@{
03292 
03293         /// Sets the Auxiliary Busses to route the specified game object
03294         /// To clear the game object's auxiliary sends, \c in_uNumSendValues must be 0.
03295         /// \sa 
03296         /// - \ref soundengine_environments
03297         /// - \ref soundengine_environments_dynamic_aux_bus_routing
03298         /// - \ref soundengine_environments_id_vs_string
03299         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03300         /// \return 
03301         /// - AK_Success if successful
03302         /// - AK_InvalidParameter if a duplicated environment is found in the array
03303         AK_EXTERNAPIFUNC( AKRESULT, SetGameObjectAuxSendValues )( 
03304             AkGameObjectID      in_gameObjectID,        ///< Associated game object ID
03305             AkAuxSendValue*     in_aAuxSendValues,      ///< Variable-size array of AkAuxSendValue structures
03306                                                         ///< (it may be NULL if no environment must be set)
03307             AkUInt32            in_uNumSendValues       ///< The number of auxiliary busses at the pointer's address
03308                                                         ///< (it must be 0 if no environment is set)
03309             );
03310 
03311         /// Registers a callback to allow the game to modify or override the volume to be applied at the output of an audio bus.
03312         /// The callback must be registered once per bus ID.
03313         /// Call with <tt>in_pfnCallback = NULL</tt> to unregister.
03314         /// \aknote The bus in_busID needs to be a mixing bus.\endaknote
03315         /// \aknote Beware when using this callback on the Master Audio Bus: since the output of this bus is not a bus, but is instead a system end-point, <tt>AkSpeakerVolumeMatrixCallbackInfo::pMixerContext</tt> will be \c NULL. You cannot modify panning at the output of the Master Audio Bus.\endaknote
03316         /// \sa 
03317         /// - \ref goingfurther_speakermatrixcallback
03318         /// - \ref soundengine_environments
03319         /// - AkSpeakerVolumeMatrixCallbackInfo
03320         /// - <tt>AK::IAkMixerInputContext</tt>
03321         /// - <tt>AK::IAkMixerPluginContext</tt>
03322         /// \return 
03323         /// - AK_Success if successful
03324         AK_EXTERNAPIFUNC( AKRESULT, RegisterBusVolumeCallback )( 
03325             AkUniqueID in_busID,                        ///< Bus ID, as obtained by GetIDFromString( bus_name ).
03326             AkBusCallbackFunc in_pfnCallback            ///< Callback function.
03327             );
03328 
03329         /// Registers a callback to be called to allow the game to access metering data from any mixing bus. You may use this to monitor loudness at any point of the mixing hierarchy 
03330         /// by querying the peak, RMS, True Peak and K-weighted power (according to loudness standard ITU BS.1770). See \ref goingfurther_speakermatrixcallback for an example.
03331         /// The callback must be registered once per bus ID.
03332         /// Call with in_pfnCallback = NULL to unregister.
03333         /// \aknote The bus in_busID needs to be a mixing bus.\endaknote
03334         /// \sa 
03335         /// - \ref goingfurther_speakermatrixcallback
03336         /// - AkBusMeteringCallbackFunc
03337         /// - <tt>AK::IAkMetering</tt>
03338         /// \return 
03339         /// - AK_Success if successful
03340         AK_EXTERNAPIFUNC( AKRESULT, RegisterBusMeteringCallback )( 
03341             AkUniqueID in_busID,                        ///< Bus ID, as obtained by GetIDFromString( bus_name ).
03342             AkBusMeteringCallbackFunc in_pfnCallback,   ///< Callback function.
03343             AkMeteringFlags in_eMeteringFlags           ///< Metering flags.
03344             );
03345 
03346         /// Sets the Output Bus Volume (direct) to be used for the specified game object.
03347         /// The control value is a number ranging from 0.0f to 1.0f.
03348         /// Output Bus Volumes are stored per listener association, so calling this function will override the default set of listeners. The game object in_emitterObjID will now reference its own set of listeners which will 
03349         /// be the same as the old set of listeners, but with the new associated gain.  Future changes to the default listener set will not be picked up by this game object unless ResetListenersToDefault() is called.
03350         /// \sa 
03351         /// - \ref AK::SoundEngine::ResetListenersToDefault
03352         /// - \ref soundengine_environments
03353         /// - \ref soundengine_environments_setting_dry_environment
03354         /// - \ref soundengine_environments_id_vs_string
03355         /// \return Always returns AK_Success
03356         AK_EXTERNAPIFUNC( AKRESULT, SetGameObjectOutputBusVolume )( 
03357             AkGameObjectID      in_emitterObjID,        ///< Associated emitter game object ID
03358             AkGameObjectID      in_listenerObjID,       ///< Associated listener game object ID. Pass AK_INVALID_GAME_OBJECT to set the Output Bus Volume for all connected listeners.
03359             AkReal32            in_fControlValue        ///< A multiplier where 0 means silence and 1 means no change. 
03360                                                         ///< (Therefore, values between 0 and 1 will attenuate the sound, and values greater than 1 will amplify it.)
03361             );
03362 
03363         /// Sets an Effect ShareSet at the specified audio node and Effect slot index.
03364         /// The target node cannot be a Bus, to set effects on a bus, use SetBusEffect() instead.
03365         /// \aknote The option "Override Parent" in 
03366         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's effect will 
03367         /// still be the one in use and the call to SetActorMixerEffect will have no impact.
03368         /// \endaknote
03369         /// \return Always returns AK_Success
03370         AK_EXTERNAPIFUNC( AKRESULT, SetActorMixerEffect )( 
03371             AkUniqueID in_audioNodeID,                  ///< Can be a member of the Actor-Mixer or Interactive Music Hierarchy (not a bus).
03372             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03373             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03374             );
03375 
03376         /// Sets an Effect ShareSet at the specified bus and Effect slot index.
03377         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03378         /// This adds a reference on the audio node to an existing ShareSet.
03379         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03380         /// Bus which does not have any Effects, or removing the last Effect on a currently playing bus.
03381         /// \endaknote
03382         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03383         /// the top of the hierarchy and is in the actor-mixer hierarchy, the option "Override Parent" in 
03384         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03385         /// still be the one in use and the call to SetBusEffect will have no impact.
03386         /// \endaknote
03387         /// \return Always returns AK_Success
03388         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03389             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03390             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03391             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the Effect slot
03392             );
03393 
03394 #ifdef AK_SUPPORT_WCHAR
03395         /// Sets an Effect ShareSet at the specified Bus and Effect slot index.
03396         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03397         /// This adds a reference on the audio node to an existing ShareSet.
03398         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03399         /// bus which does not have any Effects, or removing the last Effect on a currently playing Bus.
03400         /// \endaknote
03401         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03402         /// the top of the hierarchy and is in the Actor-Mixer Hierarchy, the option "Override Parent" in 
03403         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03404         /// still be the one in use and the call to \c SetBusEffect will have no impact.
03405         /// \endaknote
03406         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03407         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03408             const wchar_t* in_pszBusName,               ///< Bus name
03409             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03410             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03411             );
03412 #endif //AK_SUPPORT_WCHAR
03413 
03414         /// Sets an Effect ShareSet at the specified Bus and Effect slot index.
03415         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03416         /// This adds a reference on the audio node to an existing ShareSet.
03417         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03418         /// Bus which does not have any effects, or removing the last Effect on a currently playing bus.
03419         /// \endaknote
03420         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03421         /// the top of the hierarchy and is in the Actor-Mixer Hierarchy, the option "Override Parent" in 
03422         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03423         /// still be the one in use and the call to SetBusEffect will have no impact.
03424         /// \endaknote
03425         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03426         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03427             const char* in_pszBusName,      ///< Bus name
03428             AkUInt32 in_uFXIndex,           ///< Effect slot index (0-3)
03429             AkUniqueID in_shareSetID        ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03430             );
03431 
03432         /// Sets a Mixer ShareSet at the specified bus.
03433         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03434         /// Bus which does not have any Effects or mixer, or removing the last mixer on a currently playing Bus.
03435         /// \endaknote
03436         /// \aknote This function will replace existing mixers on the node. 
03437         /// \endaknote
03438         /// \return Always returns AK_Success
03439         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03440             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03441             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03442             );
03443 
03444 #ifdef AK_SUPPORT_WCHAR
03445         /// Sets a Mixer ShareSet at the specified bus.
03446         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03447         /// bus which does not have any effects nor mixer, or removing the last mixer on a currently playing bus.
03448         /// \endaknote
03449         /// \aknote This function will replace existing mixers on the node. 
03450         /// \endaknote
03451         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03452         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03453             const wchar_t* in_pszBusName,               ///< Bus name
03454             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03455             );
03456 #endif //AK_SUPPORT_WCHAR
03457 
03458         /// Sets a Mixer ShareSet at the specified bus.
03459         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03460         /// bus which does not have any effects nor mixer, or removing the last mixer on a currently playing bus.
03461         /// \endaknote
03462         /// \aknote This function will replace existing mixers on the node.
03463         /// \endaknote
03464         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03465         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03466             const char* in_pszBusName,      ///< Bus name
03467             AkUniqueID in_shareSetID        ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03468             );
03469 
03470         /// Forces channel configuration for the specified bus.
03471         /// \aknote You cannot change the configuration of the master bus.\endaknote
03472         /// 
03473         /// \return Always returns AK_Success
03474         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03475             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03476             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03477             );
03478 
03479 #ifdef AK_SUPPORT_WCHAR
03480         /// Forces channel configuration for the specified bus.
03481         /// \aknote You cannot change the configuration of the master bus.\endaknote
03482         /// 
03483         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03484         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03485             const wchar_t* in_pszBusName,               ///< Bus name
03486             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03487             );
03488 #endif //AK_SUPPORT_WCHAR
03489 
03490         /// Forces channel configuration for the specified bus.
03491         /// \aknote You cannot change the configuration of the master bus.\endaknote
03492         /// 
03493         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03494         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03495             const char* in_pszBusName,                  ///< Bus name
03496             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03497             );
03498 
03499         /// Sets a game object's obstruction and occlusion levels. If SetMultiplePositions were used, values are set for all positions.
03500         /// This function is used to affect how an object should be heard by a specific listener.
03501         /// \sa 
03502         /// - \ref soundengine_obsocc
03503         /// - \ref soundengine_environments
03504         /// \return Always returns AK_Success
03505         AK_EXTERNAPIFUNC( AKRESULT, SetObjectObstructionAndOcclusion )(  
03506             AkGameObjectID in_EmitterID,        ///< Emitter game object ID
03507             AkGameObjectID in_ListenerID,       ///< Listener game object ID
03508             AkReal32 in_fObstructionLevel,      ///< ObstructionLevel: [0.0f..1.0f]
03509             AkReal32 in_fOcclusionLevel         ///< OcclusionLevel: [0.0f..1.0f]
03510             );
03511 
03512         /// Sets a game object's obstruction and occlusion level for each positions defined by SetMultiplePositions.
03513         /// This function differs from SetObjectObstructionAndOcclusion as a list of obstruction/occlusion pair is provided
03514         /// and each obstruction/occlusion pair will affect the corresponding position defined at the same index.
03515         /// \aknote In the case the number of obstruction/occlusion pairs is smaller than the number of positions, remaining positions' 
03516         /// obstrucion/occlusion values are set to 0.0. \endaknote
03517         /// \sa
03518         /// - \ref soundengine_obsocc
03519         /// - \ref soundengine_environments
03520         /// \return AK_Success if occlusion/obstruction values are successfully stored for this emitter
03521         AK_EXTERNAPIFUNC( AKRESULT, SetMultipleObstructionAndOcclusion )(
03522             AkGameObjectID in_EmitterID,                                        ///< Emitter game object ID
03523             AkGameObjectID in_uListenerID,                                      ///< Listener game object ID
03524             AkObstructionOcclusionValues* in_fObstructionOcclusionValues,       ///< Array of obstruction/occlusion pairs to apply
03525                                                                                 ///< ObstructionLevel: [0.0f..1.0f]
03526                                                                                 ///< OcclusionLevel: [0.0f..1.0f]
03527             AkUInt32 in_uNumOcclusionObstruction                                ///< Number of obstruction/occlusion pairs specified in the provided array
03528             );
03529 
03530         /// Saves the playback history of container structures.
03531         /// This function will write history data for all currently loaded containers and instantiated game
03532         /// objects (for example, current position in Sequence Containers and previously played elements in
03533         /// Random Containers). 
03534         /// \remarks
03535         /// This function acquires the main audio lock, and may block the caller for several milliseconds.
03536         /// \sa 
03537         /// - <tt>AK::SoundEngine::SetContainerHistory()</tt>
03538         AK_EXTERNAPIFUNC( AKRESULT, GetContainerHistory)(
03539             AK::IWriteBytes * in_pBytes         ///< Pointer to IWriteBytes interface used to save the history.
03540             );
03541 
03542         /// Restores the playback history of container structures.
03543         /// This function will read history data from the passed-in stream reader interface, and apply it to all
03544         /// currently loaded containers and instantiated game objects. Game objects are matched by
03545         /// ID. History for unloaded structures and unknown game objects will be skipped.
03546         /// \remarks
03547         /// This function acquires the main audio lock, and may block the caller for several milliseconds.
03548         /// \sa 
03549         /// - <tt>AK::SoundEngine::GetContainerHistory()</tt>
03550         AK_EXTERNAPIFUNC(AKRESULT, SetContainerHistory)(
03551             AK::IReadBytes * in_pBytes          ///< Pointer to IReadBytes interface used to load the history.
03552             );
03553 
03554         //@}
03555         
03556         ////////////////////////////////////////////////////////////////////////
03557         /// @name Capture
03558         //@{
03559 
03560         /// Starts recording the sound engine audio output. 
03561         /// StartOutputCapture outputs a wav file per current output device of the sound engine.
03562         /// If more than one device is active, the system will create multiple files in the same output 
03563         /// directory and will append numbers at the end of the provided filename.
03564         ///
03565         /// If no device is running yet, the system will return success AK_Success despite doing nothing.
03566         /// Use \ref RegisterAudioDeviceStatusCallback to get notified when devices are created/destructed.
03567         ///
03568         /// \return AK_Success if successful, AK_Fail if there was a problem starting the output capture.
03569         /// \remark
03570         ///     - The sound engine opens a stream for writing using <tt>AK::IAkStreamMgr::CreateStd()</tt>. If you are using the
03571         ///         default implementation of the Stream Manager, file opening is executed in your implementation of 
03572         ///         the Low-Level IO interface <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>. The following 
03573         ///         AkFileSystemFlags are passed: uCompanyID = AKCOMPANYID_AUDIOKINETIC and uCodecID = AKCODECID_PCM,
03574         ///         and the AkOpenMode is AK_OpenModeWriteOvrwr. Refer to \ref streamingmanager_lowlevel_location for
03575         ///         more details on managing the deployment of your Wwise generated data.
03576         /// \sa 
03577         /// - <tt>AK::SoundEngine::StopOutputCapture()</tt>
03578         /// - <tt>AK::StreamMgr::SetFileLocationResolver()</tt>
03579         /// - \ref streamingdevicemanager
03580         /// - \ref streamingmanager_lowlevel_location
03581         AK_EXTERNAPIFUNC( AKRESULT, StartOutputCapture )( 
03582             const AkOSChar* in_CaptureFileName              ///< Name of the output capture file
03583             );
03584 
03585         /// Stops recording the sound engine audio output. 
03586         /// \return AK_Success if successful, AK_Fail if there was a problem stopping the output capture.
03587         /// \sa 
03588         /// - <tt>AK::SoundEngine::StartOutputCapture()</tt>
03589         AK_EXTERNAPIFUNC( AKRESULT, StopOutputCapture )();
03590 
03591         /// Adds text marker in audio output file. 
03592         /// \return AK_Success if successful, AK_Fail if there was a problem adding the output marker.
03593         /// \sa 
03594         /// - <tt>AK::SoundEngine::StartOutputCapture()</tt>
03595         AK_EXTERNAPIFUNC( AKRESULT, AddOutputCaptureMarker )(
03596             const char* in_MarkerText                   ///< Text of the marker
03597             );
03598             
03599         /// Starts recording the sound engine profiling information into a file. This file can be read
03600         /// by Wwise Authoring.
03601         /// \remark This function is provided as a utility tool only. It does nothing if it is 
03602         ///         called in the release configuration and returns AK_NotCompatible.
03603         AK_EXTERNAPIFUNC( AKRESULT, StartProfilerCapture )( 
03604             const AkOSChar* in_CaptureFileName              ///< Name of the output profiler file (.prof extension recommended)
03605             );
03606 
03607         /// Stops recording the sound engine profiling information. 
03608         /// \remark This function is provided as a utility tool only. It does nothing if it is 
03609         ///         called in the release configuration and returns AK_NotCompatible.
03610         AK_EXTERNAPIFUNC( AKRESULT, StopProfilerCapture )();
03611 
03612         //@}
03613 
03614         ////////////////////////////////////////////////////////////////////////
03615         /// @name Secondary Outputs
03616         //@{
03617 
03618         /// Adds an output to the sound engine. Use this to add controller-attached headphones, controller speakers, DVR output, etc.  
03619         /// The in_Settings parameter contains an Audio Device shareset to specify the output plugin to use and a device ID to specify the instance, if necessary (e.g. which game controller).
03620         /// \sa AkOutputSettings for more details.
03621         /// \sa \ref integrating_secondary_outputs
03622         /// \sa \ref default_audio_devices
03623         /// \return 
03624         /// - AK_NotImplemented: Feature not supported
03625         /// - AK_InvalidParameter: Out of range parameters or unsupported parameter combinations (see parameter list below).
03626         /// - AK_IDNotFound: The audioDeviceShareset on in_settings doesn't exist.  Possibly, the Init bank isn't loaded yet or was not updated with latest changes.
03627         /// - AK_DeviceNotReady: The idDevice on in_settings doesn't match with a valid hardware device.  Either the device doesn't exist or is disabled.  Disconnected devices (headphones) are not considered "not ready" therefore won't cause this error.
03628         /// - AK_Success: Parameters are valid.     
03629         AK_EXTERNAPIFUNC(AKRESULT, AddOutput)(          
03630             const AkOutputSettings & in_Settings,   ///< Creation parameters for this output.  \ref AkOutputSettings                            
03631             AkOutputDeviceID *out_pDeviceID = NULL, ///< (Optional) Output ID to use with all other Output management functions.  Leave to NULL if not required. \ref AK::SoundEngine::GetOutputID
03632             const AkGameObjectID* in_pListenerIDs = NULL,   ///< Specific listener(s) to attach to this device. 
03633                                                             ///< If specified, only the sounds routed to game objects linked to those listeners will play in this device.  
03634                                                             ///< It is necessary to have separate listeners if multiple devices of the same type can coexist (e.g. controller speakers)
03635                                                             ///< If not specified, sound routing simply obey the associations between Master Busses and Audio Devices setup in the Wwise Project.
03636             AkUInt32 in_uNumListeners = 0                   ///< The number of elements in the in_pListenerIDs array.
03637             );
03638 
03639         /// Removes one output added through AK::SoundEngine::AddOutput
03640         /// If a listener was associated with the device, you should consider unregistering the listener prior to call RemoveOutput 
03641         /// so that Game Object/Listener routing is properly updated according to your game scenario.
03642         /// \sa \ref integrating_secondary_outputs
03643         /// \sa AK::SoundEngine::AddOutput
03644         /// \return AK_Success: Parameters are valid.
03645         AK_EXTERNAPIFUNC(AKRESULT, RemoveOutput)(
03646             AkOutputDeviceID in_idOutput    ///< ID of the output to remove.  Use the returned ID from AddOutput, GetOutputID, or ReplaceOutput
03647             );
03648 
03649         /// Replaces an output device previously created during engine initialization or from AddOutput, with a new output device.
03650         /// In addition to simply removing one output device and adding a new one, the new output device will also be used on all of the master buses
03651         /// that the old output device was associated with, and preserve all listeners that were attached to the old output device.
03652         /// \sa AK::SoundEngine::AddOutput
03653         /// \return 
03654         /// - AK_InvalidID: The audioDeviceShareset on in_settings was not valid.
03655         /// - AK_IDNotFound: The audioDeviceShareset on in_settings doesn't exist.  Possibly, the Init bank isn't loaded yet or was not updated with latest changes.
03656         /// - AK_DeviceNotReady: The idDevice on in_settings doesn't match with a valid hardware device.  Either the device doesn't exist or is disabled.  Disconnected devices (headphones) are not considered "not ready" therefore won't cause this error.
03657         /// - AK_DeviceNotFound: The in_outputDeviceId provided does not match with any of the output devices that the sound engine is currently using.
03658         /// - AK_InvalidParameter: Out of range parameters or unsupported parameter combinations on in_settings
03659         /// - AK_Success: parameters were valid, and the remove and add will occur.
03660         AK_EXTERNAPIFUNC(AKRESULT, ReplaceOutput)(
03661             const AkOutputSettings & in_Settings,               ///< Creation parameters for this output.  \ref AkOutputSettings
03662             AkOutputDeviceID in_outputDeviceId,                 ///< AkOutputDeviceID of the output to replace. For example, use the AkOuptutDeviceID returned from AddOutput() or ReplaceOutput(), or generated by GetOutputID()
03663             AkOutputDeviceID *out_pOutputDeviceId = NULL        ///< (Optional) Pointer into which the method writes the AkOutputDeviceID of the new output device. If the call fails, the value pointed to will not be modified.
03664             );
03665 
03666         /// Gets the compounded output ID from shareset and device id.
03667         /// Outputs are defined by their type (Audio Device shareset) and their specific system ID.  A system ID could be reused for other device types on some OS or platforms, hence the compounded ID.
03668         /// \return The id of the output                    
03669         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03670             AkUniqueID in_idShareset,       ///< Audio Device ShareSet ID, as defined in the Wwise Project.  If needed, use AK::SoundEngine::GetIDFromString() to convert from a string.  Set to AK_INVALID_UNIQUE_ID to use the default.
03671             AkUInt32 in_idDevice            ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03672                                             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03673                                             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03674                                             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03675                                             ///< - All others output: use 0 to select the default device for that type.
03676             );
03677 
03678         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03679             const char* in_szShareSet,          ///< Audio Device ShareSet Name, as defined in the Wwise Project.  If Null, will select the Default Output shareset (always available)
03680             AkUInt32 in_idDevice                ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03681             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03682             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03683             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03684             ///< - All others output: use 0 to select the default device for that type.
03685             );
03686 
03687         #ifdef AK_SUPPORT_WCHAR
03688         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03689             const wchar_t* in_szShareSet,           ///< Audio Device ShareSet Name, as defined in the Wwise Project.  If Null, will select the Default Output shareset (always available)
03690             AkUInt32 in_idDevice            ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03691             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03692             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03693             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03694             ///< - All others output: use 0 to select the default device for that type.
03695             );
03696         #endif
03697 
03698         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03699         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03700         /// SetBusDevice must be preceded by a call to AddOutput for the new device shareset to be registered as an output.
03701         /// \return 
03702         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03703         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03704         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03705             AkUniqueID in_idBus,            ///< Id of the master bus
03706             AkUniqueID in_idNewDevice       ///< New device shareset to replace with.
03707             );
03708 
03709         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03710         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03711         /// SetBusDevice must be preceded by a call to AddOutput for the new device shareset to be registered as an output.
03712         /// \return 
03713         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03714         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03715         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03716             const char*  in_BusName,        ///< Name of the master bus
03717             const char*  in_DeviceName      ///< New device shareset to replace with.
03718             );
03719 
03720         #ifdef AK_SUPPORT_WCHAR
03721         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03722         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03723         /// SetBusDevice must be preceded by a call to AddOutput for the new device shareset to be registered as an output.
03724         /// \return 
03725         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03726         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03727         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03728             const wchar_t*  in_BusName,     ///< Name of the master bus
03729             const wchar_t*  in_DeviceName   ///< New device shareset to replace with.
03730             );
03731         #endif
03732         
03733         /// Sets the volume of a output device.     
03734         AK_EXTERNAPIFUNC( AKRESULT, SetOutputVolume )(
03735             AkOutputDeviceID in_idOutput,   ///< Output ID to set the volume on.  As returned from AddOutput or GetOutputID
03736             AkReal32 in_fVolume             ///< Volume (0.0 = Muted, 1.0 = Volume max)
03737             );
03738 
03739         /// Returns whether or not the audio device matching the device ID provided supports spatial audio (i.e. the functionality is enabled, and more than 0 dynamic objects are supported).
03740         /// If Spatial Audio is supported, then you can call Init, AddOutput, or ReplaceOutput with an Audio Device Shareset corresponding to the respective platform-specific plug-in that
03741         /// provides spatial audio, such as the Microsoft Spatial Sound Platform for Windows. Note that on Xbox One, you need to call EnableSpatialAudio() before the sound engine is
03742         /// initialized, or initialize the sound engine with AkPlatformInitSettings::bEnableSpatialAudio set to true if you want spatial audio support; otherwise this will always return AK_NotCompatible.
03743         /// \return
03744         /// AK_NotCompatible when the device ID provided does not support spatial audio, or the platform does not support spatial audio
03745         /// AK_Fail when there is some other miscellaneous failure, or the device ID provided does not match a device that the system knows about
03746         /// AK_Success when the device ID provided does support spatial audio
03747         AK_EXTERNAPIFUNC( AKRESULT, GetDeviceSpatialAudioSupport ) (
03748             AkUInt32 in_idDevice            ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03749                                             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03750                                             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03751                                             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03752                                             ///< - All others output: use 0 to select the default device for that type.
03753             );
03754 
03755 
03756         //@}
03757 
03758         /// This function should be called to put the sound engine in background mode, where audio isn't processed anymore. This needs to be called if the console has a background mode or some suspended state.
03759         /// Call \c WakeupFromSuspend when your application receives the message from the OS that the process is back in foreground.
03760         /// When suspended, the sound engine will process API messages (like PostEvent and SetSwitch) only when \ref RenderAudio() is called. 
03761         /// It is recommended to match the <b>in_bRenderAnyway</b> parameter with the behavior of the rest of your game: 
03762         /// if your game still runs in background and you must keep some kind of coherent state between the audio engine and game, then allow rendering.
03763         /// If you want to minimize CPU when in background, then don't allow rendering and never call RenderAudio from the game.
03764         ///
03765         /// - Android: Call for APP_CMD_PAUSE
03766         /// - iOS: Don't call. All audio interrupts are handled internally.
03767         /// - XBoxOne: Use when entering constrained mode or suspended mode (see ResourceAvailability in Xbox One documentation).
03768         /// \sa \ref WakeupFromSuspend
03769         AK_EXTERNAPIFUNC( AKRESULT, Suspend )(
03770             bool in_bRenderAnyway = false /// If set to true, audio processing will still occur, but not outputted. When set to false, no audio will be processed at all, even upon reception of RenderAudio().
03771             );
03772 
03773         /// This function should be called to wake up the sound engine and start processing audio again. This needs to be called if the console has a background mode or some suspended state.
03774         /// - Android: Call for APP_CMD_RESUME
03775         /// - iOS: Don't call. All audio interrupts are handled internally.     
03776         /// - XBoxOne: Use when the game is back to Full resources (see ResourceAvailability in Xbox One documentation).
03777         AK_EXTERNAPIFUNC( AKRESULT, WakeupFromSuspend )(); 
03778 
03779         /// Obtains the current audio output buffer tick. This corresponds to the number of buffers produced by
03780         /// the sound engine since initialization. 
03781         /// \return Tick count.
03782         AK_EXTERNAPIFUNC(AkUInt32, GetBufferTick)();
03783     }
03784 }
03785 
03786 #endif // _AK_SOUNDENGINE_H_