Table of Contents

include/AK/SoundEngine/Common/AkTypes.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 // AkTypes.h
00029 
00030 /// \file 
00031 /// Data type definitions.
00032 
00033 #ifndef _AK_DATA_TYPES_H_
00034 #define _AK_DATA_TYPES_H_
00035 
00036 // Platform-specific section.
00037 //----------------------------------------------------------------------------------------------------
00038 #include <AK/AkPlatforms.h>
00039 
00040 
00041 //----------------------------------------------------------------------------------------------------
00042 
00043 #include <AK/SoundEngine/Common/AkSoundEngineExport.h>
00044 
00045 #ifndef NULL
00046     #ifdef __cplusplus
00047         #define NULL    0
00048     #else
00049         #define NULL    ((void *)0)
00050     #endif
00051 #endif
00052 
00053 #if defined(AK_CPU_X86_64) || defined(AK_CPU_ARM_64)
00054 #define AK_POINTER_64
00055 #endif // #if defined(AK_CPU_X86_64) || defined(AK_CPU_ARM_64)
00056 
00057 typedef AkInt32             AkAtomic32;         ///< Signed 32-bit integer - Atomic Declaration
00058 typedef AkInt64             AkAtomic64;         ///< Signed 64-bit integer - Atomic Declaration
00059 typedef AkUInt32            AkAtomicU32;        ///< Unsigned 32-bit integer - Atomic Declaration
00060 typedef AkIntPtr            AkAtomicPtr;        ///< Signed platform sized integer - Atomic Declaration
00061 
00062 typedef AkUInt32        AkUniqueID;                 ///< Unique 32-bit ID
00063 typedef AkUInt32        AkStateID;                  ///< State ID
00064 typedef AkUInt32        AkStateGroupID;             ///< State group ID
00065 typedef AkUInt32        AkPlayingID;                ///< Playing ID
00066 typedef AkInt32         AkTimeMs;                   ///< Time in ms
00067 typedef AkUInt16        AkPortNumber;               ///< Port number
00068 typedef AkReal32        AkPitchValue;               ///< Pitch value
00069 typedef AkReal32        AkVolumeValue;              ///< Volume value( also apply to LFE )
00070 typedef AkUInt64        AkGameObjectID;             ///< Game object ID
00071 typedef AkReal32        AkLPFType;                  ///< Low-pass filter type
00072 typedef AkInt32         AkMemPoolId;                ///< Memory pool ID
00073 typedef AkUInt32        AkPluginID;                 ///< Source or effect plug-in ID
00074 typedef AkUInt32        AkCodecID;                  ///< Codec plug-in ID
00075 typedef AkUInt32        AkAuxBusID;                 ///< Auxilliary bus ID
00076 typedef AkInt16         AkPluginParamID;            ///< Source or effect plug-in parameter ID
00077 typedef AkInt8          AkPriority;                 ///< Priority
00078 typedef AkUInt16        AkDataCompID;               ///< Data compression format ID
00079 typedef AkUInt16        AkDataTypeID;               ///< Data sample type ID
00080 typedef AkUInt8         AkDataInterleaveID;         ///< Data interleaved state ID
00081 typedef AkUInt32        AkSwitchGroupID;            ///< Switch group ID
00082 typedef AkUInt32        AkSwitchStateID;            ///< Switch ID
00083 typedef AkUInt32        AkRtpcID;                   ///< Real time parameter control ID
00084 typedef AkReal32        AkRtpcValue;                ///< Real time parameter control value
00085 typedef AkUInt32        AkBankID;                   ///< Run time bank ID
00086 typedef AkUInt32        AkFileID;                   ///< Integer-type file identifier
00087 typedef AkUInt32        AkDeviceID;                 ///< I/O device ID
00088 typedef AkUInt32        AkTriggerID;                ///< Trigger ID
00089 typedef AkUInt32        AkArgumentValueID;          ///< Argument value ID
00090 typedef AkUInt32        AkChannelMask;              ///< Channel mask (similar to WAVE_FORMAT_EXTENSIBLE). Bit values are defined in AkSpeakerConfig.h.
00091 typedef AkUInt32        AkModulatorID;              ///< Modulator ID
00092 typedef AkUInt32        AkAcousticTextureID;        ///< Acoustic Texture ID
00093 typedef AkUInt32        AkImageSourceID;            ///< Image Source ID
00094 typedef AkUInt64        AkOutputDeviceID;           ///< Audio Output device ID
00095 
00096 // Constants.
00097 static const AkPluginID                 AK_INVALID_PLUGINID                 = (AkPluginID)-1;       ///< Invalid FX ID
00098 static const AkGameObjectID             AK_INVALID_GAME_OBJECT              = (AkGameObjectID)-1;   ///< Invalid game object (may also mean all game objects)
00099 static const AkUniqueID                 AK_INVALID_UNIQUE_ID                =  0;                   ///< Invalid unique 32-bit ID
00100 static const AkRtpcID                   AK_INVALID_RTPC_ID                  =  AK_INVALID_UNIQUE_ID;///< Invalid RTPC ID
00101 static const AkPlayingID                AK_INVALID_PLAYING_ID               =  AK_INVALID_UNIQUE_ID;///< Invalid playing ID
00102 static const AkUInt32                   AK_DEFAULT_SWITCH_STATE             =  0;                   ///< Switch selected if no switch has been set yet
00103 static const AkMemPoolId                AK_INVALID_POOL_ID                  = -1;                   ///< Invalid pool ID
00104 static const AkMemPoolId                AK_DEFAULT_POOL_ID                  = -1;                   ///< Default pool ID, same as AK_INVALID_POOL_ID
00105 static const AkAuxBusID                 AK_INVALID_AUX_ID                   =  AK_INVALID_UNIQUE_ID;///< Invalid auxiliary bus ID (or no Aux bus ID)
00106 static const AkFileID                   AK_INVALID_FILE_ID                  = (AkFileID)-1;         ///< Invalid file ID
00107 static const AkDeviceID                 AK_INVALID_DEVICE_ID                = (AkDeviceID)-1;       ///< Invalid streaming device ID
00108 static const AkBankID                   AK_INVALID_BANK_ID                  =  AK_INVALID_UNIQUE_ID;///< Invalid bank ID
00109 static const AkArgumentValueID          AK_FALLBACK_ARGUMENTVALUE_ID        =  0;                   ///< Fallback argument value ID
00110 static const AkChannelMask              AK_INVALID_CHANNELMASK              =  0;                   ///< Invalid channel mask
00111 static const AkUInt32                   AK_INVALID_OUTPUT_DEVICE_ID         =  AK_INVALID_UNIQUE_ID;///< Invalid Device ID
00112 
00113 // Priority.
00114 static const AkPriority                 AK_DEFAULT_PRIORITY                 =  50;                  ///< Default sound / I/O priority
00115 static const AkPriority                 AK_MIN_PRIORITY                     =  0;                   ///< Minimal priority value [0,100]
00116 static const AkPriority                 AK_MAX_PRIORITY                     =  100;                 ///< Maximal priority value [0,100]
00117 
00118 // Default bank I/O settings.
00119 static const AkPriority                 AK_DEFAULT_BANK_IO_PRIORITY         = AK_DEFAULT_PRIORITY;  ///<  Default bank load I/O priority
00120 static const AkReal32                   AK_DEFAULT_BANK_THROUGHPUT          = 1*1024*1024/1000.f;   ///<  Default bank load throughput (1 Mb/ms)
00121 
00122 // Bank version
00123 static const AkUInt32                   AK_SOUNDBANK_VERSION =              134;                    ///<  Version of the soundbank reader
00124 
00125 /// Standard function call result.
00126 enum AKRESULT
00127 {
00128     AK_NotImplemented           = 0,    ///< This feature is not implemented.
00129     AK_Success                  = 1,    ///< The operation was successful.
00130     AK_Fail                     = 2,    ///< The operation failed.
00131     AK_PartialSuccess           = 3,    ///< The operation succeeded partially.
00132     AK_NotCompatible            = 4,    ///< Incompatible formats
00133     AK_AlreadyConnected         = 5,    ///< The stream is already connected to another node.
00134     AK_InvalidFile              = 7,    ///< An unexpected value causes the file to be invalid.
00135     AK_AudioFileHeaderTooLarge  = 8,    ///< The file header is too large.
00136     AK_MaxReached               = 9,    ///< The maximum was reached.
00137     AK_InvalidID                = 14,   ///< The ID is invalid.
00138     AK_IDNotFound               = 15,   ///< The ID was not found.
00139     AK_InvalidInstanceID        = 16,   ///< The InstanceID is invalid.
00140     AK_NoMoreData               = 17,   ///< No more data is available from the source.
00141     AK_InvalidStateGroup        = 20,   ///< The StateGroup is not a valid channel.
00142     AK_ChildAlreadyHasAParent   = 21,   ///< The child already has a parent.
00143     AK_InvalidLanguage          = 22,   ///< The language is invalid (applies to the Low-Level I/O).
00144     AK_CannotAddItseflAsAChild  = 23,   ///< It is not possible to add itself as its own child.
00145     AK_InvalidParameter         = 31,   ///< Something is not within bounds.
00146     AK_ElementAlreadyInList     = 35,   ///< The item could not be added because it was already in the list.
00147     AK_PathNotFound             = 36,   ///< This path is not known.
00148     AK_PathNoVertices           = 37,   ///< Stuff in vertices before trying to start it
00149     AK_PathNotRunning           = 38,   ///< Only a running path can be paused.
00150     AK_PathNotPaused            = 39,   ///< Only a paused path can be resumed.
00151     AK_PathNodeAlreadyInList    = 40,   ///< This path is already there.
00152     AK_PathNodeNotInList        = 41,   ///< This path is not there.
00153     AK_DataNeeded               = 43,   ///< The consumer needs more.
00154     AK_NoDataNeeded             = 44,   ///< The consumer does not need more.
00155     AK_DataReady                = 45,   ///< The provider has available data.
00156     AK_NoDataReady              = 46,   ///< The provider does not have available data.
00157     AK_InsufficientMemory       = 52,   ///< Memory error.
00158     AK_Cancelled                = 53,   ///< The requested action was cancelled (not an error).
00159     AK_UnknownBankID            = 54,   ///< Trying to load a bank using an ID which is not defined.
00160     AK_BankReadError            = 56,   ///< Error while reading a bank.
00161     AK_InvalidSwitchType        = 57,   ///< Invalid switch type (used with the switch container)
00162     AK_FormatNotReady           = 63,   ///< Source format not known yet.
00163     AK_WrongBankVersion         = 64,   ///< The bank version is not compatible with the current bank reader.
00164     AK_FileNotFound             = 66,   ///< File not found.
00165     AK_DeviceNotReady           = 67,   ///< Specified ID doesn't match a valid hardware device: either the device doesn't exist or is disabled.
00166     AK_BankAlreadyLoaded        = 69,   ///< The bank load failed because the bank is already loaded.
00167     AK_RenderedFX               = 71,   ///< The effect on the node is rendered.
00168     AK_ProcessNeeded            = 72,   ///< A routine needs to be executed on some CPU.
00169     AK_ProcessDone              = 73,   ///< The executed routine has finished its execution.
00170     AK_MemManagerNotInitialized = 74,   ///< The memory manager should have been initialized at this point.
00171     AK_StreamMgrNotInitialized  = 75,   ///< The stream manager should have been initialized at this point.
00172     AK_SSEInstructionsNotSupported = 76,///< The machine does not support SSE instructions (required on PC).
00173     AK_Busy                     = 77,   ///< The system is busy and could not process the request.
00174     AK_UnsupportedChannelConfig = 78,   ///< Channel configuration is not supported in the current execution context.
00175     AK_PluginMediaNotAvailable  = 79,   ///< Plugin media is not available for effect.
00176     AK_MustBeVirtualized        = 80,   ///< Sound was Not Allowed to play.
00177     AK_CommandTooLarge          = 81,   ///< SDK command is too large to fit in the command queue.
00178     AK_RejectedByFilter         = 82,   ///< A play request was rejected due to the MIDI filter parameters.
00179     AK_InvalidCustomPlatformName= 83,   ///< Detecting incompatibility between Custom platform of banks and custom platform of connected application
00180     AK_DLLCannotLoad            = 84,   ///< Plugin DLL could not be loaded, either because it is not found or one dependency is missing.
00181     AK_DLLPathNotFound          = 85,   ///< Plugin DLL search path could not be found.
00182     AK_NoJavaVM                 = 86,   ///< No Java VM provided in AkInitSettings.
00183     AK_OpenSLError              = 87,   ///< OpenSL returned an error.  Check error log for more details.
00184     AK_PluginNotRegistered      = 88,   ///< Plugin is not registered.  Make sure to implement a AK::PluginRegistration class for it and use AK_STATIC_LINK_PLUGIN in the game binary.
00185     AK_DataAlignmentError       = 89,   ///< A pointer to audio data was not aligned to the platform's required alignment (check AkTypes.h in the platform-specific folder)
00186     AK_DeviceNotCompatible      = 90,   ///< Incompatible Audio device.
00187     AK_DuplicateUniqueID        = 91,   ///< Two Wwise objects share the same ID.
00188     AK_InitBankNotLoaded        = 92,   ///< The Init bank was not loaded yet, the sound engine isn't completely ready yet.
00189     AK_DeviceNotFound           = 93,   ///< The specified device ID does not match with any of the output devices that the sound engine is currently using.
00190 };
00191 
00192 /// Game sync group type
00193 enum AkGroupType
00194 {
00195     // should stay set as Switch = 0 and State = 1
00196     AkGroupType_Switch  = 0, ///< Type switch
00197     AkGroupType_State   = 1  ///< Type state
00198 };
00199 
00200 /// Configured audio settings
00201 struct AkAudioSettings
00202 {
00203     AkUInt32            uNumSamplesPerFrame;        ///< Number of samples per audio frame (256, 512, 1024 or 2048).
00204     AkUInt32            uNumSamplesPerSecond;       ///< Number of samples per second.
00205 };
00206 
00207 /// This structure allows the game to provide audio files to fill the external sources. See \ref AK::SoundEngine::PostEvent
00208 /// You can specify a streaming file or a file in-memory, regardless of the "Stream" option in the Wwise project.  
00209 /// \akwarning
00210 /// Make sure that only one of szFile, pInMemory or idFile is non-null. if both idFile and szFile are set, idFile is passed to low-level IO and szFile is used as stream name (for profiling purposes).
00211 /// \endakwarning
00212 struct AkExternalSourceInfo
00213 {
00214     AkUInt32 iExternalSrcCookie;    ///< Cookie identifying the source, given by hashing the name of the source given in the project.  See \ref AK::SoundEngine::GetIDFromString. \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures. \endaknote
00215     AkCodecID idCodec;              ///< Codec ID for the file.  One of the audio formats defined in AkTypes.h (AKCODECID_XXX)
00216     AkOSChar * szFile;              ///< File path for the source.  If not NULL, the source will be streaming from disk.  Set pInMemory to NULL. If idFile is set, this field is used as stream name (for profiling purposes).
00217     void* pInMemory;                ///< Pointer to the in-memory file.  If not NULL, the source will be read from memory.  Set szFile and idFile to NULL.
00218     AkUInt32 uiMemorySize;          ///< Size of the data pointed by pInMemory
00219     AkFileID idFile;                ///< File ID.  If not zero, the source will be streaming from disk.  This ID can be anything.  Note that you must override the low-level IO to resolve this ID to a real file.  See \ref streamingmanager_lowlevel for more information on overriding the Low Level IO.
00220 
00221     /// Default constructor.
00222     AkExternalSourceInfo()
00223         : iExternalSrcCookie( 0 )
00224         , idCodec( 0 )
00225         , szFile( 0 )
00226         , pInMemory( 0 )
00227         , uiMemorySize( 0 )
00228         , idFile( 0 ) {}
00229 
00230     /// Constructor: specify source by memory.
00231     AkExternalSourceInfo( 
00232         void* in_pInMemory,             ///< Pointer to the in-memory file.
00233         AkUInt32 in_uiMemorySize,       ///< Size of data.
00234         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00235         AkCodecID in_idCodec            ///< Codec ID.
00236         )
00237         : iExternalSrcCookie( in_iExternalSrcCookie )
00238         , idCodec( in_idCodec )
00239         , szFile( 0 )
00240         , pInMemory( in_pInMemory )
00241         , uiMemorySize( in_uiMemorySize )
00242         , idFile( 0 ) {}
00243 
00244     /// Constructor: specify source by streaming file name.
00245     AkExternalSourceInfo( 
00246         AkOSChar * in_pszFileName,      ///< File name.
00247         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00248         AkCodecID in_idCodec            ///< Codec ID.
00249         )
00250         : iExternalSrcCookie( in_iExternalSrcCookie )
00251         , idCodec( in_idCodec )
00252         , szFile( in_pszFileName )
00253         , pInMemory( 0 )
00254         , uiMemorySize( 0 )
00255         , idFile( 0 ) {}
00256 
00257     /// Constructor: specify source by streaming file ID.
00258     AkExternalSourceInfo( 
00259         AkFileID in_idFile,             ///< File ID.
00260         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00261         AkCodecID in_idCodec            ///< Codec ID.
00262         )
00263         : iExternalSrcCookie( in_iExternalSrcCookie )
00264         , idCodec( in_idCodec )
00265         , szFile( 0 )
00266         , pInMemory( 0 )
00267         , uiMemorySize( 0 )
00268         , idFile( in_idFile ) {}
00269 };
00270 
00271 /// Nature of the connection binding an input to a bus.
00272 enum AkConnectionType
00273 {
00274     ConnectionType_Direct = 0x0,            ///< Direct (main, dry) connection.
00275     ConnectionType_GameDefSend = 0x1,       ///< Connection by a game-defined send.
00276     ConnectionType_UserDefSend = 0x2,       ///< Connection by a user-defined send.
00277 };
00278 
00279 /// 3D vector.
00280 struct AkVector
00281 {
00282     inline AkVector operator+(const AkVector& b) const
00283     {
00284         AkVector v;
00285 
00286         v.X = X + b.X;
00287         v.Y = Y + b.Y;
00288         v.Z = Z + b.Z;
00289 
00290         return v;
00291     }
00292 
00293     inline void Zero()
00294     {
00295         X = 0; Y = 0; Z = 0;
00296     }
00297 
00298     AkReal32        X;  ///< X Position
00299     AkReal32        Y;  ///< Y Position
00300     AkReal32        Z;  ///< Z Position
00301 };
00302 
00303 /// Position and orientation of game objects.
00304 class AkTransform
00305 {
00306 public:
00307     //
00308     // Getters.
00309     //
00310 
00311     /// Get position vector.
00312     inline const AkVector & Position() const
00313     {
00314         return position;
00315     }
00316 
00317     /// Get orientation front vector.
00318     inline const AkVector & OrientationFront() const
00319     {
00320         return orientationFront;
00321     }
00322 
00323     /// Get orientation top vector.
00324     inline const AkVector & OrientationTop() const
00325     {
00326         return orientationTop;
00327     }
00328 
00329     //
00330     // Setters.
00331     //
00332 
00333     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
00334     inline void Set(
00335         const AkVector & in_position,           ///< Position vector.
00336         const AkVector & in_orientationFront,   ///< Orientation front
00337         const AkVector & in_orientationTop      ///< Orientation top
00338         )
00339     {
00340         position = in_position;
00341         orientationFront = in_orientationFront;
00342         orientationTop = in_orientationTop;
00343     }
00344 
00345     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
00346     inline void Set(
00347         AkReal32 in_positionX,                  ///< Position x
00348         AkReal32 in_positionY,                  ///< Position y
00349         AkReal32 in_positionZ,                  ///< Position z
00350         AkReal32 in_orientFrontX,               ///< Orientation front x
00351         AkReal32 in_orientFrontY,               ///< Orientation front y
00352         AkReal32 in_orientFrontZ,               ///< Orientation front z
00353         AkReal32 in_orientTopX,                 ///< Orientation top x
00354         AkReal32 in_orientTopY,                 ///< Orientation top y
00355         AkReal32 in_orientTopZ                  ///< Orientation top z
00356         )
00357     {
00358         position.X = in_positionX;
00359         position.Y = in_positionY;
00360         position.Z = in_positionZ;
00361         orientationFront.X = in_orientFrontX;
00362         orientationFront.Y = in_orientFrontY;
00363         orientationFront.Z = in_orientFrontZ;
00364         orientationTop.X = in_orientTopX;
00365         orientationTop.Y = in_orientTopY;
00366         orientationTop.Z = in_orientTopZ;
00367     }
00368     
00369     /// Set position.
00370     inline void SetPosition(
00371         const AkVector & in_position            ///< Position vector.
00372         )
00373     {
00374         position = in_position;
00375     }
00376 
00377     /// Set position.
00378     inline void SetPosition(
00379         AkReal32 in_x,                          ///< x
00380         AkReal32 in_y,                          ///< y
00381         AkReal32 in_z                           ///< z
00382         )
00383     {
00384         position.X = in_x;
00385         position.Y = in_y;
00386         position.Z = in_z;
00387     }
00388 
00389     /// Set orientation. Orientation front and top should be orthogonal and normalized.
00390     inline void SetOrientation(
00391         const AkVector & in_orientationFront,   ///< Orientation front
00392         const AkVector & in_orientationTop      ///< Orientation top
00393         )
00394     {
00395         orientationFront = in_orientationFront; 
00396         orientationTop = in_orientationTop;
00397     }   
00398 
00399     /// Set orientation. Orientation front and top should be orthogonal and normalized.
00400     inline void SetOrientation(
00401         AkReal32 in_orientFrontX,               ///< Orientation front x
00402         AkReal32 in_orientFrontY,               ///< Orientation front y
00403         AkReal32 in_orientFrontZ,               ///< Orientation front z
00404         AkReal32 in_orientTopX,                 ///< Orientation top x
00405         AkReal32 in_orientTopY,                 ///< Orientation top y
00406         AkReal32 in_orientTopZ                  ///< Orientation top z
00407         )
00408     {
00409         orientationFront.X = in_orientFrontX;
00410         orientationFront.Y = in_orientFrontY;
00411         orientationFront.Z = in_orientFrontZ;
00412         orientationTop.X = in_orientTopX;
00413         orientationTop.Y = in_orientTopY;
00414         orientationTop.Z = in_orientTopZ;
00415     }
00416 
00417 private:
00418     AkVector        orientationFront;   ///< Orientation of the listener
00419     AkVector        orientationTop;     ///< Top orientation of the listener
00420     AkVector        position;           ///< Position of the listener
00421 };
00422 
00423 /// Positioning information for a sound.
00424 typedef AkTransform AkSoundPosition;
00425 
00426 /// Positioning information for a listener.
00427 typedef AkTransform AkListenerPosition;
00428 
00429 /// Obstruction/occlusion pair for a position
00430 struct AkObstructionOcclusionValues
00431 {
00432     AkReal32 occlusion;    ///< OcclusionLevel: [0.0f..1.0f]
00433     AkReal32 obstruction;  ///< ObstructionLevel: [0.0f..1.0f]
00434 };
00435 
00436 /// Positioning information for a sound, with specified subset of its channels.
00437 struct AkChannelEmitter
00438 {
00439     AkTransform     position;       ///< Emitter position.
00440     AkChannelMask   uInputChannels; ///< Channels to which the above position applies.
00441 };
00442 
00443 /// Polar coordinates.
00444 struct AkPolarCoord
00445 {
00446     AkReal32        r;              ///< Norm/distance
00447     AkReal32        theta;          ///< Azimuth
00448 };
00449 
00450 /// Spherical coordinates.
00451 struct AkSphericalCoord : public AkPolarCoord
00452 {
00453     AkReal32        phi;            ///< Elevation
00454 };
00455 
00456 /// Emitter-listener pair: Positioning data pertaining to a single pair of emitter and listener.
00457 class AkEmitterListenerPair
00458 {
00459 public:
00460     /// Constructor.
00461     AkEmitterListenerPair()
00462         : fDistance(0.f)
00463         , fEmitterAngle(0.f)
00464         , fListenerAngle(0.f)   
00465         , fDryMixGain(1.f)
00466         , fGameDefAuxMixGain(1.f)
00467         , fUserDefAuxMixGain(1.f)
00468         , fOcclusion(0.f)
00469         , fObstruction(0.f)
00470         , fSpread(0.f)
00471         , fFocus(0.f)
00472         , uEmitterChannelMask(0xFFFFFFFF)
00473         , m_uListenerID(0)
00474     {
00475     }
00476     /// Destructor.
00477     ~AkEmitterListenerPair() {}
00478 
00479     /// Get distance.
00480     inline AkReal32 Distance() const { return fDistance; }
00481 
00482     /// Get the absolute angle, in radians between 0 and pi, of the emitter's orientation relative to 
00483     /// the line that joins the emitter and the listener.
00484     inline AkReal32 EmitterAngle() const { return fEmitterAngle; }
00485 
00486     /// Get the absolute angle, in radians between 0 and pi, of the listener's orientation relative to
00487     /// the line that joins the emitter and the listener
00488     inline AkReal32 ListenerAngle() const { return fListenerAngle; }
00489 
00490     /// Get the occlusion factor for this emitter-listener pair
00491     inline AkReal32 Occlusion() const { return fOcclusion; }
00492 
00493     /// Get the obstruction factor for this emitter-listener pair
00494     inline AkReal32 Obstruction() const { return fObstruction; }    
00495 
00496     /// Get the emitter-listener-pair-specific gain (due to distance and cone attenuation), linear [0,1], for a given connection type.
00497     inline AkReal32 GetGainForConnectionType(AkConnectionType in_eType) const
00498     {
00499         if (in_eType == ConnectionType_Direct)
00500             return fDryMixGain;
00501         else if (in_eType == ConnectionType_GameDefSend)
00502             return fGameDefAuxMixGain;
00503         else
00504             return fUserDefAuxMixGain;
00505     }
00506 
00507     /// Get listener ID associated with the emitter-listener pair.
00508     inline AkGameObjectID ListenerID() const { return m_uListenerID; }
00509     
00510     AkTransform emitter;                /// Emitter position.
00511     AkReal32 fDistance;                 /// Distance between emitter and listener.
00512     AkReal32 fEmitterAngle;             /// Angle between position vector and emitter orientation.
00513     AkReal32 fListenerAngle;            /// Angle between position vector and listener orientation. 
00514     AkReal32 fDryMixGain;               /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for direct connections.
00515     AkReal32 fGameDefAuxMixGain;        /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for game-defined send connections.
00516     AkReal32 fUserDefAuxMixGain;        /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for user-defined send connections.
00517     AkReal32 fOcclusion;                /// Emitter-listener-pair-specific occlusion factor
00518     AkReal32 fObstruction;              /// Emitter-listener-pair-specific obstruction factor
00519     AkReal32 fSpread;                   /// Emitter-listener-pair-specific spread
00520     AkReal32 fFocus;                    /// Emitter-listener-pair-specific focus
00521     AkChannelMask uEmitterChannelMask;  /// Channels of the emitter that apply to this ray.
00522 protected:
00523     AkGameObjectID m_uListenerID;       /// Listener game object ID.
00524 };
00525 
00526 /// Listener information.
00527 struct AkListener
00528 {
00529     AkListener()
00530         : fScalingFactor( 1.0f )
00531         , bSpatialized( true )
00532     {}
00533     AkListenerPosition  position;       /// Listener position (see AK::SoundEngine::SetPosition()).
00534     AkReal32            fScalingFactor; /// Listener scaling factor (see AK::SoundEngine::SetListenerScalingFactor()).
00535     bool                bSpatialized;   /// Whether listener is spatialized or not (see AK::SoundEngine::SetListenerSpatialization()).
00536 };
00537 
00538 // If you modify AkCurveInterpolation, don't forget to modify WAAPI validation schema accordingly.
00539 
00540 /// Curve interpolation types
00541 enum AkCurveInterpolation
00542 {
00543 //DONT GO BEYOND 15! (see below for details)
00544 //Curves from 0 to LastFadeCurve NEED TO BE A MIRROR IMAGE AROUND LINEAR (eg. Log3 is the inverse of Exp3)
00545     AkCurveInterpolation_Log3           = 0, ///< Log3
00546     AkCurveInterpolation_Sine           = 1, ///< Sine
00547     AkCurveInterpolation_Log1           = 2, ///< Log1
00548     AkCurveInterpolation_InvSCurve      = 3, ///< Inversed S Curve
00549     AkCurveInterpolation_Linear         = 4, ///< Linear (Default)
00550     AkCurveInterpolation_SCurve         = 5, ///< S Curve
00551     AkCurveInterpolation_Exp1           = 6, ///< Exp1
00552     AkCurveInterpolation_SineRecip      = 7, ///< Reciprocal of sine curve
00553     AkCurveInterpolation_Exp3           = 8, ///< Exp3
00554     AkCurveInterpolation_LastFadeCurve  = 8, ///< Update this value to reflect last curve available for fades
00555     AkCurveInterpolation_Constant       = 9  ///< Constant ( not valid for fading values )
00556 //DONT GO BEYOND 15! The value is stored on 5 bits,
00557 //but we can use only 4 bits for the actual values, keeping
00558 //the 5th bit at 0 to void problems when the value is
00559 //expanded to 32 bits.
00560 };
00561 #define AKCURVEINTERPOLATION_NUM_STORAGE_BIT 5 ///< Internal storage restriction, for internal use only.
00562 
00563 /// Auxiliary bus sends information per game object per given auxiliary bus.
00564 struct AkAuxSendValue
00565 {
00566     AkGameObjectID listenerID;  ///< Game object ID of the listener associated with this send. Use AK_INVALID_GAME_OBJECT as a wildcard to set the auxiliary send to all connected listeners (see AK::SoundEngine::SetListeners).
00567     AkAuxBusID auxBusID;        ///< Auxiliary bus ID.
00568     AkReal32 fControlValue;     ///< Value in the range [0.0f:1.0f], send level to auxiliary bus.   
00569 };
00570 
00571 /// Volume ramp specified by end points "previous" and "next".
00572 struct AkRamp
00573 {
00574     AkRamp() : fPrev( 1.f ), fNext( 1.f ) {}
00575     AkRamp( AkReal32 in_fPrev, AkReal32 in_fNext ) : fPrev( in_fPrev ), fNext( in_fNext ) {}
00576     AkRamp & operator*=(const AkRamp& in_rRhs) { fPrev *= in_rRhs.fPrev; fNext *= in_rRhs.fNext; return *this; }
00577 
00578     AkReal32 fPrev;
00579     AkReal32 fNext; 
00580 };
00581 inline AkRamp operator*(const AkRamp& in_rLhs, const AkRamp& in_rRhs) 
00582 {
00583     AkRamp result(in_rLhs);
00584     result *= in_rRhs;
00585     return result;
00586 }
00587 
00588 #ifndef AK_MEMPOOLATTRIBUTES
00589 
00590     /// Memory pool attributes.
00591     /// Block allocation type determines the method used to allocate
00592     /// a memory pool. Block management type determines the
00593     /// method used to manage memory blocks. Note that
00594     /// the list of values in this enum is platform-dependent.
00595     /// \sa
00596     /// - AkMemoryMgr::CreatePool()
00597     /// - AK::Comm::DEFAULT_MEMORY_POOL_ATTRIBUTES
00598     enum AkMemPoolAttributes
00599     {
00600         AkNoAlloc       = 0,    ///< CreatePool will not allocate memory.  You need to allocate the buffer yourself.
00601         AkMalloc        = 1,    ///< CreatePool will use AK::AllocHook() to allocate the memory block.
00602         AkAllocMask     = AkNoAlloc | AkMalloc,                     ///< Block allocation type mask.
00603 
00604         AkFixedSizeBlocksMode   = 1<<3,         ///< Block management type: Fixed-size blocks. Get blocks through GetBlock/ReleaseBlock API.  If not specified, use AkAlloc/AkFree.
00605         AkBlockMgmtMask = AkFixedSizeBlocksMode ///< Block management type mask.
00606     };
00607     #define AK_MEMPOOLATTRIBUTES
00608 
00609 #endif
00610 
00611 namespace AK
00612 {   
00613     /// External allocation hook for the Memory Manager. Called by the Audiokinetic 
00614     /// implementation of the Memory Manager when creating a pool of type AkMalloc.
00615     /// \aknote This needs to be defined by the client. \endaknote
00616     /// \return A pointer to the start of the allocated memory (NULL if the system is out of memory)
00617     /// \sa
00618     /// - \ref memorymanager
00619     /// - AK::FreeHook()
00620     AK_EXTERNFUNC( void *, AllocHook )( 
00621         size_t in_size          ///< Number of bytes to allocate
00622         );
00623 
00624     /// External deallocation hook for the Memory Manager. Called by the Audiokinetic 
00625     /// implementation of the Memory Manager when destroying a pool of type AkMalloc.
00626     /// \aknote This needs to be defined by the client. \endaknote
00627     /// \sa 
00628     /// - \ref memorymanager
00629     /// - AK::AllocHook()
00630     AK_EXTERNFUNC( void, FreeHook )( 
00631         void * in_pMemAddress   ///< Pointer to the start of memory allocated with AllocHook
00632         );
00633 }
00634 
00635 // ---------------------------------------------------------------
00636 // Languages
00637 // ---------------------------------------------------------------
00638 #define AK_MAX_LANGUAGE_NAME_SIZE   (32)
00639 
00640 // ---------------------------------------------------------------
00641 // File Type ID Definitions
00642 // ---------------------------------------------------------------
00643 
00644 // These correspond to IDs specified in the conversion plug-ins' XML
00645 // files. Audio sources persist them to "remember" their format.
00646 // DO NOT CHANGE THEM without talking to someone in charge of persistence!
00647 
00648 // Company ID for plugin development.
00649 #define AKCOMPANYID_PLUGINDEV_MIN       (64)
00650 #define AKCOMPANYID_PLUGINDEV_MAX       (255)
00651 
00652 // Vendor ID.
00653 #define AKCOMPANYID_AUDIOKINETIC        (0)     ///< Audiokinetic inc.
00654 #define AKCOMPANYID_AUDIOKINETIC_EXTERNAL (1)   ///< Audiokinetic inc.
00655 #define AKCOMPANYID_MCDSP               (256)   ///< McDSP
00656 #define AKCOMPANYID_WAVEARTS            (257)   ///< WaveArts
00657 #define AKCOMPANYID_PHONETICARTS        (258)   ///< Phonetic Arts
00658 #define AKCOMPANYID_IZOTOPE             (259)   ///< iZotope
00659 #define AKCOMPANYID_CRANKCASEAUDIO      (261)   ///< Crankcase Audio
00660 #define AKCOMPANYID_IOSONO              (262)   ///< IOSONO
00661 #define AKCOMPANYID_AUROTECHNOLOGIES    (263)   ///< Auro Technologies
00662 #define AKCOMPANYID_DOLBY               (264)   ///< Dolby
00663 #define AKCOMPANYID_TWOBIGEARS          (265)   ///< Two Big Ears
00664 #define AKCOMPANYID_OCULUS              (266)   ///< Oculus
00665 #define AKCOMPANYID_BLUERIPPLESOUND     (267)   ///< Blue Ripple Sound
00666 #define AKCOMPANYID_ENZIEN              (268)   ///< Enzien Audio
00667 #define AKCOMPANYID_KROTOS              (269)   ///< Krotos (Dehumanizer)
00668 #define AKCOMPANYID_NURULIZE            (270)   ///< Nurulize
00669 #define AKCOMPANYID_SUPERPOWERED        (271)   ///< Super Powered
00670 #define AKCOMPANYID_GOOGLE              (272)   ///< Google
00671 //#define AKCOMPANYID_NVIDIA            (273)   ///< NVIDIA     // Commented out to avoid redefinition, provider is already defining it.
00672 //#define AKCOMPANYID_RESERVED          (274)   ///< Reserved   // Commented out to avoid redefinition, provider is already defining it.
00673 //#define AKCOMPANYID_MICROSOFT         (275)   ///< Microsoft  // Commented out to avoid redefinition, provider is already defining it.
00674 //#define AKCOMPANYID_YAMAHA            (276)   ///< YAMAHA     // Commented out to avoid redefinition, provider is already defining it.
00675 #define AKCOMPANYID_VISISONICS          (277)   ///< Visisonics
00676 
00677 // File/encoding types of Audiokinetic.
00678 #define AKCODECID_BANK                  (0)     ///< Bank encoding
00679 #define AKCODECID_PCM                   (1)     ///< PCM encoding
00680 #define AKCODECID_ADPCM                 (2)     ///< ADPCM encoding
00681 #define AKCODECID_XMA                   (3)     ///< XMA encoding
00682 #define AKCODECID_VORBIS                (4)     ///< Vorbis encoding
00683 #define AKCODECID_WIIADPCM              (5)     ///< ADPCM encoding on the Wii
00684 #define AKCODECID_PCMEX                 (7)     ///< Standard PCM WAV file parser for Wwise Authoring
00685 #define AKCODECID_EXTERNAL_SOURCE       (8)     ///< External Source (unknown encoding)
00686 #define AKCODECID_XWMA                  (9)     ///< xWMA encoding
00687 #define AKCODECID_AAC                   (10)    ///< AAC encoding (only available on Apple devices) -- see AkAACFactory.h
00688 #define AKCODECID_FILE_PACKAGE          (11)    ///< File package files generated by the File Packager utility.
00689 #define AKCODECID_ATRAC9                (12)    ///< ATRAC-9 encoding
00690 #define AKCODECID_VAG                   (13)    ///< VAG/HE-VAG encoding
00691 #define AKCODECID_PROFILERCAPTURE       (14)    ///< Profiler capture file (.prof) as written through AK::SoundEngine::StartProfilerCapture
00692 #define AKCODECID_ANALYSISFILE          (15)    ///< Analysis file
00693 #define AKCODECID_MIDI                  (16)    ///< MIDI file
00694 #define AKCODECID_OPUSNX                (17)    ///< OpusNX encoding
00695 #define AKCODECID_CAF                   (18)    ///< CAF file
00696 #define AKCODECID_AKOPUS                (19)    ///< Opus encoding
00697 
00698 #define AKPLUGINID_METER                (129)  ///< Meter Plugin
00699 #define AKPLUGINID_RECORDER             (132)  ///< Recorder Plugin
00700 
00701 #define AKEXTENSIONID_SPATIALAUDIO      (800)   ///< Spatial Audio
00702 #define AKEXTENSIONID_INTERACTIVEMUSIC  (801)   ///< Interactive Music
00703 #define AKEXTENSIONID_EVENTMGRTHREAD    (900)   ///< Profiling: Event Manager
00704 
00705 //The following are internally defined
00706 #define AK_WAVE_FORMAT_VAG              0xFFFB
00707 #define AK_WAVE_FORMAT_AT9              0xFFFC
00708 #define AK_WAVE_FORMAT_VORBIS           0xFFFF
00709 #define AK_WAVE_FORMAT_AAC              0xAAC0
00710 #define AK_WAVE_FORMAT_OPUSNX           0x3039
00711 #define AK_WAVE_FORMAT_OPUS             0x3040
00712 #define WAVE_FORMAT_XMA2                0x166
00713 
00714 class IAkSoftwareCodec;
00715 /// Registered file source creation function prototype.
00716 AK_CALLBACK( IAkSoftwareCodec*, AkCreateFileSourceCallback )( void* in_pCtx );
00717 /// Registered bank source node creation function prototype.
00718 AK_CALLBACK( IAkSoftwareCodec*, AkCreateBankSourceCallback )( void* in_pCtx );
00719 
00720 //-----------------------------------------------------------------------------
00721 // Positioning
00722 //-----------------------------------------------------------------------------
00723 
00724 namespace AK
00725 {
00726     namespace SoundEngine
00727     {
00728         // If you modify MultiPositionType, don't forget to modify WAAPI validation schema accordingly.
00729 
00730         /// MultiPositionType.
00731         /// \sa
00732         /// - AK::SoundEngine::SetMultiplePosition()
00733         /// - \ref soundengine_3dpositions_multiplepos
00734         enum MultiPositionType
00735         {
00736             MultiPositionType_SingleSource,     ///< Used for normal sounds, not expected to pass to AK::SoundEngine::SetMultiplePosition() (if done, only the first position will be used).
00737             MultiPositionType_MultiSources,     ///< Simulate multiple sources in one sound playing, adding volumes. For instance, all the torches on your level emitting using only one sound.
00738             MultiPositionType_MultiDirections   ///< Simulate one sound coming from multiple directions. Useful for repositionning sounds based on wall openings or to simulate areas like forest or rivers ( in combination with spreading in the attenuation of the sounds ).
00739         };
00740     }
00741 }
00742 
00743 #define AK_PANNER_NUM_STORAGE_BITS 3
00744 /// Speaker panning type: type of panning logic when object is not 3D spatialized (i.e. when Ak3DSpatializationMode is AK_SpatializationMode_None).
00745 enum AkSpeakerPanningType
00746 {
00747     AK_DirectSpeakerAssignment  = 0,    ///< No panning: route to matching channels between input and output.
00748     AK_BalanceFadeHeight        = 1     ///< Balance-Fade-Height: Traditional "box" or "car"-like panner.
00749 };
00750 
00751 #define AK_POSSOURCE_NUM_STORAGE_BITS 3
00752 /// 3D position type: defines what acts as the emitter position for computing spatialization against the listener. Used when Ak3DSpatializationMode is AK_SpatializationMode_PositionOnly or AK_SpatializationMode_PositionAndOrientation.
00753 enum Ak3DPositionType
00754 {
00755     AK_3DPositionType_Emitter = 0,                  ///< 3D spatialization is computed directly from the emitter game object position.
00756     AK_3DPositionType_EmitterWithAutomation = 1,    ///< 3D spatialization is computed from the emitter game object position, translated by user-defined automation.
00757     AK_3DPositionType_ListenerWithAutomation = 2    ///< 3D spatialization is computed from the listener game object position, translated by user-defined automation.
00758 };
00759 
00760 /// Headphone / speakers panning rules
00761 enum AkPanningRule
00762 {
00763     AkPanningRule_Speakers      = 0,    ///< Left and right positioned 60 degrees apart (by default - see AK::SoundEngine::GetSpeakerAngles()).
00764     AkPanningRule_Headphones    = 1     ///< Left and right positioned 180 degrees apart.
00765 };
00766 
00767 #define AK_SPAT_NUM_STORAGE_BITS 3
00768 /// 3D spatialization mode.
00769 enum Ak3DSpatializationMode
00770 {
00771     AK_SpatializationMode_None = 0,                     ///< No spatialization
00772     AK_SpatializationMode_PositionOnly = 1,             ///< Spatialization based on emitter position only.
00773     AK_SpatializationMode_PositionAndOrientation = 2    ///< Spatialization based on both emitter position and emitter orientation.
00774 };
00775 
00776 /// Bus type bit field.
00777 enum AkBusHierarchyFlags
00778 {
00779     AkBusHierarchy_Primary      = 1 << 0,   ///< Flag is set to indicate the primary bus hierarchy.
00780     AkBusHierarchy_Secondary    = 1 << 1,   ///< Flag is set to indicate the secondary bus hierarchy.
00781     AkBusHierarchy_IsMaster     = 1 << 7    ///< Flag is set to indicate a master bus (may be used in combination with other flags).
00782 };
00783 
00784 #define AK_MAX_BITS_METERING_FLAGS  (5) // Keep in sync with AkMeteringFlags.
00785 
00786 /// Metering flags. Used for specifying bus metering, through AK::SoundEngine::RegisterBusVolumeCallback() or AK::IAkMixerPluginContext::SetMeteringFlags().
00787 enum AkMeteringFlags
00788 {
00789     AK_NoMetering               = 0,            ///< No metering.
00790     AK_EnableBusMeter_Peak      = 1 << 0,       ///< Enable computation of peak metering.
00791     AK_EnableBusMeter_TruePeak  = 1 << 1,       ///< Enable computation of true peak metering (most CPU and memory intensive).
00792     AK_EnableBusMeter_RMS       = 1 << 2,       ///< Enable computation of RMS metering.
00793     // 1 << 3 is reserved.
00794     AK_EnableBusMeter_KPower    = 1 << 4,       ///< Enable computation of K-weighted power metering (used as a basis for computing loudness, as defined by ITU-R BS.1770).
00795     AK_EnableBusMeter_3DMeter = 1 << 5
00796 };
00797 
00798 /// Plug-in type.
00799 /// \sa
00800 /// - AkPluginInfo
00801 enum AkPluginType
00802 {
00803     AkPluginTypeNone = 0,   ///< Unknown/invalid plug-in type.
00804     AkPluginTypeCodec = 1,  ///< Compressor/decompressor plug-in (allows support for custom audio file types).
00805     AkPluginTypeSource = 2, ///< Source plug-in: creates sound by synthesis method (no input, just output).
00806     AkPluginTypeEffect = 3, ///< Effect plug-in: applies processing to audio data.
00807     //AkPluginTypeMotionDevice = 4, ///< Motion Device plug-in: feeds movement data to devices. Deprecated by Motion refactor.
00808     //AkPluginTypeMotionSource = 5, ///< Motion Device source plug-in: feeds movement data to device busses. Deprecated by Motion refactor.
00809     AkPluginTypeMixer = 6,  ///< Mixer plug-in: mix voices at the bus level.
00810     AkPluginTypeSink = 7,   ///< Sink plug-in: implement custom sound engine end point.
00811     AkPluginTypeGlobalExtension = 8,    ///< Global Extension plug-in: (e.g. Spatial Audio, Interactive Music)
00812     AkPluginTypeMask = 0xf  ///< Plug-in type mask is 4 bits.
00813 };
00814 
00815 ////////////////////////////////////////////////////////////////////////////////
00816 // Wwise ID system
00817 ////////////////////////////////////////////////////////////////////////////////
00818 enum AkNodeType
00819 {
00820     AkNodeType_Default,
00821     AkNodeType_Bus
00822 };
00823 
00824 struct WwiseObjectIDext
00825 {
00826 public:
00827 
00828     bool operator == ( const WwiseObjectIDext& in_rOther ) const
00829     {
00830         return in_rOther.id == id && in_rOther.bIsBus == bIsBus;
00831     }
00832 
00833     AkNodeType GetType()
00834     {
00835         return bIsBus ? AkNodeType_Bus : AkNodeType_Default;
00836     }
00837 
00838     AkUniqueID  id;
00839     bool        bIsBus;
00840 };
00841 
00842 struct WwiseObjectID : public WwiseObjectIDext
00843 {
00844     WwiseObjectID()
00845     {
00846         id = AK_INVALID_UNIQUE_ID;
00847         bIsBus = false;
00848     }
00849 
00850     WwiseObjectID( AkUniqueID in_ID )
00851     {
00852         id = in_ID;
00853         bIsBus = false;
00854     }
00855 
00856     WwiseObjectID( AkUniqueID in_ID, bool in_bIsBus )
00857     {
00858         id = in_ID;
00859         bIsBus = in_bIsBus;
00860     }
00861 
00862     WwiseObjectID( AkUniqueID in_ID, AkNodeType in_eNodeType )
00863     {
00864         id = in_ID;
00865         bIsBus = in_eNodeType == AkNodeType_Bus;
00866     }
00867 };
00868 
00869 /// Public data structures for converted file format.
00870 namespace AkFileParser
00871 {
00872 #pragma pack(push, 1)
00873     /// Analyzed envelope point.
00874     struct EnvelopePoint
00875     {
00876         AkUInt32 uPosition;     /// Position of this point in samples at the source rate.
00877         AkUInt16 uAttenuation;  /// Approximate _attenuation_ at this location relative to this source's maximum, in dB (absolute value).
00878     };
00879 #pragma pack(pop)
00880 }
00881 
00882 #ifndef AK_OS_STRUCT_ALIGN
00883 #define AK_OS_STRUCT_ALIGN  4               ///< OS Structures need to be aligned at 4 bytes.
00884 #endif
00885 
00886 #ifndef AK_64B_OS_STRUCT_ALIGN
00887 #define AK_64B_OS_STRUCT_ALIGN  8               ///< OS Structures need to be aligned at 8 bytes.
00888 #endif
00889 
00890 #ifndef AK_ALIGN
00891 #define AK_ALIGN(__declaration__, uAlignmentSize) __declaration__ ///< Default definition for declaration that might need to be aligned on some platforms. By default, no alignment will be done.
00892 #endif
00893 
00894 #if !defined(AK_ENDIANNESS_LITTLE) && !defined(AK_ENDIANNESS_BIG)
00895 #define AK_ENDIANNESS_LITTLE
00896 #endif
00897 
00898 #ifndef AK_UNALIGNED
00899 #define AK_UNALIGNED                        ///< Refers to the __unaligned compilation flag available on some platforms. Note that so far, on the tested platform this should always be placed before the pointer symbol *.
00900 #endif
00901 
00902 #ifndef AK_FINAL
00903 #define AK_FINAL
00904 #endif
00905 
00906 #ifndef AK_ASYNC_OPEN_DEFAULT
00907 #define AK_ASYNC_OPEN_DEFAULT   (false)             ///< Refers to asynchronous file opening in default low-level IO.
00908 #endif
00909 
00910 #ifndef AK_COMM_DEFAULT_DISCOVERY_PORT
00911 #define AK_COMM_DEFAULT_DISCOVERY_PORT 24024    ///< Default discovery port for most platforms using IP sockets for communication.
00912 #endif
00913 
00914 #ifndef AK_CAPTURE_TYPE_FLOAT
00915 typedef AkInt16     AkCaptureType;          ///< Default value: capture type is short.
00916 #endif
00917 
00918 #define AkRegister
00919 
00920 #endif  //_AK_DATA_TYPES_H_