_ak_common_defs_8h

Wwise SDK 2024.1.0

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided 
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
 "Apache License"); you may not use this file except in compliance with the 
 Apache License. You may obtain a copy of the Apache License at 
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 // AkCommonDefs.h
  
 /// \file 
 /// AudioLib common defines, enums, and structs.
  
  
 #ifndef _AK_COMMON_DEFS_H_
 #define _AK_COMMON_DEFS_H_
  
 #include <AK/SoundEngine/Common/AkSpeakerConfig.h>
 #include <AK/SoundEngine/Common/AkSpeakerVolumes.h>
 #include <AK/Tools/Common/AkBitFuncs.h>
  
 //-----------------------------------------------------------------------------
 // AUDIO DATA FORMAT
 //-----------------------------------------------------------------------------
  
 // Audio data format.
 // ------------------------------------------------
  
 const AkDataTypeID      AK_INT              = 0;        ///< Integer data type (uchar, short, and so on)
 const AkDataTypeID      AK_FLOAT            = 1;        ///< Float data type
  
 const AkDataInterleaveID AK_INTERLEAVED     = 0;        ///< Interleaved data
 const AkDataInterleaveID AK_NONINTERLEAVED  = 1;        ///< Non-interleaved data
  
 // Native format currently the same on all supported platforms, may become platform specific in the future
 const AkUInt32 AK_LE_NATIVE_BITSPERSAMPLE  = 32;                    ///< Native number of bits per sample.
 const AkUInt32 AK_LE_NATIVE_SAMPLETYPE = AK_FLOAT;                  ///< Native data type.
 const AkUInt32 AK_LE_NATIVE_INTERLEAVE = AK_NONINTERLEAVED;         ///< Native interleaved setting.
  
 /// Defines the parameters of an audio buffer format.
 struct AkAudioFormat
 {
     AkUInt32    uSampleRate;        ///< Number of samples per second
  
     AkChannelConfig channelConfig;  ///< Channel configuration.
  
     AkUInt32    uBitsPerSample  :6; ///< Number of bits per sample.
     AkUInt32    uBlockAlign     :10;///< Number of bytes per sample frame. (For example a 5.1 PCM 16bit should have a uBlockAlign equal to 6(5.1 channels)*2(16 bits per sample) = 12.
     AkUInt32    uTypeID         :2; ///< Data type ID (AkDataTypeID). 
     AkUInt32    uInterleaveID   :1; ///< Interleave ID (AkDataInterleaveID). 
     
     /// Get the number of channels.
     /// \return The number of channels
     AkForceInline AkUInt32 GetNumChannels() const
     {
         return channelConfig.uNumChannels;
     }
  
     /// Query if LFE channel is present.
     /// \return True when LFE channel is present
     AkForceInline bool HasLFE() const
     { 
         return channelConfig.HasLFE(); 
     }
  
     /// Query if center channel is present.
     /// Note that mono configurations have one channel which is arbitrary set to AK_SPEAKER_FRONT_CENTER,
     /// so HasCenter() returns true for mono signals.
     /// \return True when center channel is present and configuration has more than 2 channels.
     AkForceInline bool HasCenter() const
     { 
         return channelConfig.HasCenter(); 
     }
  
     /// Get the number of bits per sample.
     /// \return The number of bits per sample
     AkForceInline AkUInt32 GetBitsPerSample()   const                       
     { 
         return uBitsPerSample;
     }
  
     /// Get the block alignment.
     /// \return The block alignment
     AkForceInline AkUInt32 GetBlockAlign() const
     {
         return uBlockAlign;
     }
  
     /// Get the data sample format (Float or Integer).
     /// \return The data sample format
     AkForceInline AkUInt32 GetTypeID() const
     {
         return uTypeID;
     }
  
     /// Get the interleaved type.
     /// \return The interleaved type
     AkForceInline AkUInt32 GetInterleaveID() const
     {
         return uInterleaveID;
     }
  
     /// Set all parameters of the audio format structure.
     /// Channels are specified by channel mask (standard configs).
     void SetAll(
         AkUInt32    in_uSampleRate,     ///< Number of samples per second
         AkChannelConfig in_channelConfig,   ///< Channel configuration
         AkUInt32    in_uBitsPerSample,  ///< Number of bits per sample
         AkUInt32    in_uBlockAlign,     ///< Number of bytes per sample frame. (For example a 5.1 PCM 16bit should have a uBlockAlign equal to 6(5.1 channels)*2(16 bits per sample) = 12.
         AkUInt32    in_uTypeID,         ///< Data sample format (Float or Integer)
         AkUInt32    in_uInterleaveID    ///< Interleaved type
         )
     {
         uSampleRate     = in_uSampleRate;
         channelConfig   = in_channelConfig;
         uBitsPerSample  = in_uBitsPerSample;
         uBlockAlign     = in_uBlockAlign;
         uTypeID         = in_uTypeID;
         uInterleaveID   = in_uInterleaveID;
     }
  
     AkForceInline bool operator==(const AkAudioFormat & in_other) const
     {
         return uSampleRate == in_other.uSampleRate 
             && channelConfig == in_other.channelConfig
             && uBitsPerSample == in_other.uBitsPerSample
             && uBlockAlign == in_other.uBlockAlign
             && uTypeID == in_other.uTypeID
             && uInterleaveID == in_other.uInterleaveID;
     }
  
     AkForceInline bool operator!=(const AkAudioFormat & in_other) const
     {
         return uSampleRate != in_other.uSampleRate
             || channelConfig != in_other.channelConfig
             || uBitsPerSample != in_other.uBitsPerSample
             || uBlockAlign != in_other.uBlockAlign
             || uTypeID != in_other.uTypeID
             || uInterleaveID != in_other.uInterleaveID;
     }
 };
  
 typedef AkUInt8(*AkChannelMappingFunc)(const AkChannelConfig &config, AkUInt8 idx);
  
 #define AK_MAKE_CHANNELCONFIGOVERRIDE(_config,_order)   ((AkInt64)_config.Serialize()|((AkInt64)_order<<32))
 #define AK_GET_CHANNELCONFIGOVERRIDE_CONFIG(_over)      (_over&UINT_MAX)
 #define AK_GET_CHANNELCONFIGOVERRIDE_ORDERING(_over)    ((AK::AkChannelOrdering)(_over>>32))
  
 // Build a 32 bit class identifier based on the Plug-in type,
 // CompanyID and PluginID.
 //
 // Parameters:
 //   - in_pluginType: A value from enum AkPluginType (4 bits)
 //   - in_companyID: CompanyID as defined in the Plug-in's XML file (12 bits)
 //          * 0-63: Reserved for Audiokinetic
 //          * 64-255: Reserved for clients' in-house Plug-ins
 //          * 256-4095: Assigned by Audiokinetic to third-party plug-in developers
 //   - in_pluginID: PluginID as defined in the Plug-in's XML file (16 bits)
 //          * 0-32767: Set freely by the Plug-in developer
 #define AKMAKECLASSID( in_pluginType, in_companyID, in_pluginID ) \
     ( (in_pluginType) + ( (in_companyID) << 4 ) + ( (in_pluginID) << ( 4 + 12 ) ) )
  
 #define AKGETPLUGINTYPEFROMCLASSID( in_classID ) ( (in_classID) & AkPluginTypeMask )
 #define AKGETCOMPANYIDFROMCLASSID( in_classID ) ( ( (in_classID) & 0x0000FFF0 ) >> 4 )
 #define AKGETPLUGINIDFROMCLASSID( in_classID ) ( ( (in_classID) & 0xFFFF0000 ) >> ( 4 + 12 ) )
  
 #define CODECID_FROM_PLUGINID AKGETPLUGINIDFROMCLASSID
  
  
 namespace AK
 {
     /// Struct containing metering information about a buffer. Depending on when this struct is generated, you may get metering data computed in the previous frame only. 
     struct AkMetering
     {
         /// Peak of each channel in this frame.
         /// Vector of linear peak levels, corresponding to each channel. NULL if AK_EnableBusMeter_Peak is not set (see IAkMixerPluginContext::SetMeteringFlags() or AK::SoundEngine::RegisterBusMeteringCallback()).
         AK::SpeakerVolumes::VectorPtr peak;
  
         /// True peak of each channel (as defined by ITU-R BS.1770) in this frame.
         /// Vector of linear true peak levels, corresponding to each channel. NULL if AK_EnableBusMeter_TruePeak is not set (see IAkMixerPluginContext::SetMeteringFlags() or AK::SoundEngine::RegisterBusMeteringCallback()).
         AK::SpeakerVolumes::VectorPtr truePeak;
  
         /// RMS value of each channel in this frame.
         /// Vector of linear rms levels, corresponding to each channel. NULL if AK_EnableBusMeter_RMS is not set (see IAkMixerPluginContext::SetMeteringFlags() or AK::SoundEngine::RegisterBusMeteringCallback()).
         AK::SpeakerVolumes::VectorPtr rms;
  
         /// Mean k-weighted power value in this frame, used to compute loudness (as defined by ITU-R BS.1770).
         /// Total linear k-weighted power of all channels. 0 if AK_EnableBusMeter_KPower is not set (see IAkMixerPluginContext::SetMeteringFlags() or AK::SoundEngine::RegisterBusMeteringCallback()).
         AkReal32 fMeanPowerK;
     };
  
     static inline bool IsBankCodecID(AkUInt32 in_codecID)
     {
         return in_codecID == AKCODECID_BANK ||
             in_codecID == AKCODECID_BANK_EVENT ||
             in_codecID == AKCODECID_BANK_BUS;
     }
 }
  
 // 3D Audio Object.
 // ------------------------------------------------
  
 /// Default listener transform.
 #define AK_DEFAULT_LISTENER_POSITION_X (0.0f)               // at coordinate system's origin
 #define AK_DEFAULT_LISTENER_POSITION_Y (0.0f)
 #define AK_DEFAULT_LISTENER_POSITION_Z (0.0f)
 #define AK_DEFAULT_LISTENER_FRONT_X    (0.0f)               // looking toward Z,
 #define AK_DEFAULT_LISTENER_FRONT_Y    (0.0f)
 #define AK_DEFAULT_LISTENER_FRONT_Z    (1.0f)
 #define AK_DEFAULT_TOP_X               (0.0f)               // top towards Y
 #define AK_DEFAULT_TOP_Y               (1.0f)
 #define AK_DEFAULT_TOP_Z               (0.0f)
  
  
 /// 3D data needed for 3D spatialization. 
 /// Undergoes transformations based on emitter-listener placement.
 struct Ak3dData
 {
     Ak3dData()
         : spread(1.f)
         , focus(1.f)
         , uEmitterChannelMask(0xffffffff)
     {
         xform.Set(AK_DEFAULT_LISTENER_POSITION_X, AK_DEFAULT_LISTENER_POSITION_Y, AK_DEFAULT_LISTENER_POSITION_Z, AK_DEFAULT_LISTENER_FRONT_X, AK_DEFAULT_LISTENER_FRONT_Y, AK_DEFAULT_LISTENER_FRONT_Z, AK_DEFAULT_TOP_X, AK_DEFAULT_TOP_Y, AK_DEFAULT_TOP_Z);
     }
  
     AkTransform xform;                              ///< Object position / orientation.
     AkReal32 spread;                                ///< Spread [0,1]
     AkReal32 focus;                                 ///< Focus [0,1]
     AkChannelMask uEmitterChannelMask;              ///< Emitter channel mask. With 3D spatialization, zeroed channels should be dropped.
 };
  
 /// Positioning data inherited from sound structures and mix busses.
 struct AkBehavioralPositioningData
 {
     AkBehavioralPositioningData()
         : center(1.f)
         , panLR(0.f)
         , panBF(0.f)
         , panDU(0.f)
         , panSpatMix(1.f)
         , spatMode(AK_SpatializationMode_None)
         , panType(AK_DirectSpeakerAssignment)
         , enableHeightSpread(true)
     {}
  
     AkReal32 center;                                ///< Center percentage [0,1]
     AkReal32 panLR;                                 ///< Pan left-right [-1,1]
     AkReal32 panBF;                                 ///< Pan back-front [-1,1]
     AkReal32 panDU;                                 ///< Pan down-up [-1,1]
     AkReal32 panSpatMix;                            ///< Panning vs 3D spatialization mix ([0,1], 1 being 100% spatialized).
     Ak3DSpatializationMode spatMode;                ///< 3D spatialization mode.
     AkSpeakerPanningType panType;                   ///< Speaker panning type.
     bool enableHeightSpread;                        ///< When true, audio objects 3D spatialized onto a planar channel configuration will be given a minimum spread value based on their elevation angle, equal to sin(elevation)**2.
 };
  
 /// Positioning data of 3D audio objects.
 struct AkPositioningData
 {
     Ak3dData threeD;                                ///< 3D data used for 3D spatialization.
     AkBehavioralPositioningData behavioral;         ///< Positioning data inherited from sound structures and mix busses.
 };
  
 /// Structure containing information about system-level support for 3D audio.
 /// "3D Audio" refers to a system's ability to position sound sources in a virtual 3D space, pan them accordingly on a range of physical speakers, and produce a binaural mix where appropriate.
 /// We prefer "3D Audio" to "Spatial" to avoid ambiguity with spatial audio, which typically involves sound propagation and environment effects.
 struct Ak3DAudioSinkCapabilities
 {
     AkChannelConfig channelConfig{};                              ///< Channel configuration of the main mix.
     AkUInt32        uMaxSystemAudioObjects = 0;                   ///< Maximum number of System Audio Objects that can be active concurrently. A value of zero indicates the system does not support this feature.
     AkUInt32        uAvailableSystemAudioObjects = 0;             ///< How many System Audio Objects can currently be sent to the sink. This value can change at runtime depending on what is playing. Can never be higher than uMaxSystemAudioObjects.
     bool            bPassthrough = false;                         ///< Separate  pass-through mix is supported.
     bool            bMultiChannelObjects = false;                 ///< Can handle multi-channel objects
 };
  
 /// Enum of the possible object destinations when reaching a 3D audio-capable sink
 enum class AkAudioObjectDestination
 {
     eDefault = 0,            // The destination will be chosen based on the audio object's metadata and channel configuration
     eMainMix = 1,            // The audio object will be mixed to the sink's main mix
     ePassthrough = 2,        // The audio object will be mixed to the sink's passthrough mix
     eSystemAudioObject = 3   // The audio object will not be mixed; it will be sent separately to the system's 3D audio endpoint
 };
  
 // Audio buffer.
 // ------------------------------------------------
  
 /// Native sample type. 
 /// \remarks Sample values produced by insert effects must use this type.
 /// \remarks Source plug-ins can produce samples of other types (specified through 
 /// according fields of AkAudioFormat, at initial handshaking), but these will be 
 /// format converted internally into the native format.
 /// \sa
 /// - \ref iaksourceeffect_init
 /// - \ref iakmonadiceffect_init
 typedef AkReal32 AkSampleType;  ///< Audio sample data type (32 bit floating point)
  
 /// Audio buffer structure including the address of an audio buffer, the number of valid frames inside, 
 /// and the maximum number of frames the audio buffer can hold.
 /// \sa
 /// - \ref fx_audiobuffer_struct
 class AkAudioBuffer
 {
 public:
  
     /// Constructor.
     AkAudioBuffer() 
     { 
         Clear(); 
     }
  
     /// Clear data pointer.
     AkForceInline void ClearData()
     {
         pData = NULL;
         uValidFrames = 0;
     }
  
     /// Clear members.
     AkForceInline void Clear()
     {
         ClearData();
         uMaxFrames          = 0;
         eState              = AK_DataNeeded;
     }
     
     /// \name Channel queries.
     //@{
     /// Get the number of channels.
     AkForceInline AkUInt32 NumChannels() const
     {
         return channelConfig.uNumChannels;
     }
  
     /// Returns true if there is an LFE channel present.
     AkForceInline bool HasLFE() const
     { 
         return channelConfig.HasLFE(); 
     }
  
     AkForceInline AkChannelConfig GetChannelConfig() const { return channelConfig; }
  
     //@}
  
     /// \name Interleaved interface
     //@{
     /// Get address of data: to be used with interleaved buffers only.
     /// \remarks Only source plugins can output interleaved data. This is determined at 
     /// initial handshaking.
     /// \sa 
     /// - \ref fx_audiobuffer_struct
     AkForceInline void * GetInterleavedData()
     { 
         return pData; 
     }
  
     /// Attach interleaved data. Allocation is performed outside.
     inline void AttachInterleavedData( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames )
     { 
         pData = in_pData; 
         uMaxFrames = in_uMaxFrames; 
         uValidFrames = in_uValidFrames; 
         AKASSERT(channelConfig.IsValid());
     }
     /// Attach interleaved data with a new channel config. Allocation is performed outside.
     inline void AttachInterleavedData( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig )
     { 
         pData = in_pData; 
         uMaxFrames = in_uMaxFrames; 
         uValidFrames = in_uValidFrames; 
         channelConfig = in_channelConfig; 
     }
     //@}
  
     /// \name Deinterleaved interface
     //@{
  
     /// Check if buffer has samples attached to it.
     AkForceInline bool HasData() const
     {
         return ( NULL != pData ); 
     }
  
     /// Convert a channel, identified by a single channel bit, to a buffer index used in GetChannel() below, for a given channel config.
     /// Standard indexing follows channel bit order (see AkSpeakerConfig.h). Pipeline/buffer indexing is the same but the LFE is moved to the end.
     static inline AkUInt32 StandardToPipelineIndex( 
         AkChannelConfig in_channelConfig,       ///< Channel configuration.
         AkUInt32        in_uChannelIdx          ///< Channel index in standard ordering to be converted to pipeline ordering.
         )
     {
         if ( in_channelConfig.HasLFE() )
         {
             AKASSERT( in_channelConfig.eConfigType == AK_ChannelConfigType_Standard );  // in_channelConfig.HasLFE() would not have returned true otherwise.
             AKASSERT( AK::GetNumNonZeroBits( in_channelConfig.uChannelMask ) );
             AkUInt32 uIdxLFE = AK::GetNumNonZeroBits( ( AK_SPEAKER_LOW_FREQUENCY - 1 ) & in_channelConfig.uChannelMask );
             if ( in_uChannelIdx == uIdxLFE )
                 return in_channelConfig.uNumChannels - 1;
             else if ( in_uChannelIdx > uIdxLFE )
                 return in_uChannelIdx - 1;
         }
  
         return in_uChannelIdx;
     }
  
     /// Get the buffer of the ith channel. 
     /// Access to channel data is most optimal through this method. Use whenever the
     /// speaker configuration is known, or when an operation must be made independently
     /// for each channel.
     /// \remarks When using a standard Wwise pipeline configuration, use ChannelBitToIndex() to convert channel bits to buffer indices.
     /// \return Address of the buffer of the ith channel.
     /// \sa
     /// - \ref fx_audiobuffer_struct
     /// - \ref fx_audiobuffer_struct_channels
     inline AkSampleType * GetChannel(
         AkUInt32 in_uIndex      ///< Channel index [0,NumChannels()-1]
         )
     {
         AKASSERT( in_uIndex < NumChannels() );
         return (AkSampleType*)((AkUInt8*)(pData) + ( in_uIndex * sizeof(AkSampleType) * MaxFrames() ));
     }
  
     /// Get the buffer of the LFE.
     /// \return Address of the buffer of the LFE. Null if there is no LFE channel.
     /// \sa
     /// - \ref fx_audiobuffer_struct_channels
     inline AkSampleType * GetLFE()
     {
         if ( channelConfig.uChannelMask & AK_SPEAKER_LOW_FREQUENCY )
             return GetChannel( NumChannels()-1 );
         
         return (AkSampleType*)0;
     }
  
     /// Can be used to transform an incomplete into a complete buffer with valid data.
     /// The invalid frames are made valid (zeroed out) for all channels and the validFrames count will be made equal to uMaxFrames.
     void ZeroPadToMaxFrames()
     {
         AKASSERT(pData != nullptr || MaxFrames() == 0);
         // The following members MUST be copied locally due to multi-core calls to this function.
         const AkUInt32 uNumChannels = NumChannels();
         const AkUInt32 uNumCurrentFrames = AkMin(uValidFrames, MaxFrames());
         const AkUInt32 uNumZeroFrames = MaxFrames() - uNumCurrentFrames;
         if ( uNumZeroFrames )
         {
             AKASSERT(pData != nullptr);
             for ( AkUInt32 i = 0; i < uNumChannels; ++i )
             {
                 memset( GetChannel(i) + uNumCurrentFrames, 0, uNumZeroFrames * sizeof(AkSampleType) );
             }
             uValidFrames = MaxFrames();
         }
     }
  
     /// Attach deinterleaved data where channels are contiguous in memory. Allocation is performed outside.
     AkForceInline void AttachContiguousDeinterleavedData( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig )
     { 
         AttachInterleavedData( in_pData, in_uMaxFrames, in_uValidFrames, in_channelConfig );
     }
     /// Detach deinterleaved data where channels are contiguous in memory. The address of the buffer is returned and fields are cleared.
     AkForceInline void * DetachContiguousDeinterleavedData()
     {
         uMaxFrames = 0; 
         uValidFrames = 0; 
         channelConfig.Clear();
         void * pDataOld = pData;
         pData = NULL;
         return pDataOld;
     }
  
     bool CheckValidSamples();   
  
     //@}
  
     void RelocateMedia( AkUInt8* in_pNewMedia,  AkUInt8* in_pOldMedia )
     {
         AkUIntPtr uMemoryOffset = (AkUIntPtr)in_pNewMedia - (AkUIntPtr)in_pOldMedia;
         pData = (void*) (((AkUIntPtr)pData) + uMemoryOffset);
     }
  
     /// Access to the number of sample frames the buffer can hold.
     /// \return Number of sample frames the buffer can hold.
     AkForceInline AkUInt16 MaxFrames() const { return uMaxFrames; }
  
 protected:
     void *          pData;              ///< Start of the audio buffer.
     AkChannelConfig channelConfig;      ///< Channel config.
  
 public: 
     AKRESULT        eState;             ///< Execution status
  
 protected:  
     AkUInt16        uMaxFrames;         ///< Number of sample frames the buffer can hold. Access through AkAudioBuffer::MaxFrames().
  
 public:
     AkUInt16        uValidFrames;      ///< Number of valid sample frames in the audio buffer
 };
  
 #endif // _AK_COMMON_DEFS_H_

AkAudioBuffer::HasLFE

AkForceInline bool HasLFE() const

Returns true if there is an LFE channel present.

Definition: AkCommonDefs.h:354

AkBehavioralPositioningData::enableHeightSpread

bool enableHeightSpread

When true, audio objects 3D spatialized onto a planar channel configuration will be given a minimum s...

Definition: AkCommonDefs.h:272

AkMin

#define AkMin(x1, x2)

Definition: AkPlatformFuncs.h:90

AkSpeakerVolumes.h

AkDataInterleaveID

AkUInt8 AkDataInterleaveID

Data interleaved state ID

Definition: AkTypes.h:70

AK_DirectSpeakerAssignment

@ AK_DirectSpeakerAssignment

No panning: route to matching channels between input and output.

Definition: AkTypes.h:1124

Ak3DAudioSinkCapabilities::uAvailableSystemAudioObjects

AkUInt32 uAvailableSystemAudioObjects

How many System Audio Objects can currently be sent to the sink. This value can change at runtime dep...

Definition: AkCommonDefs.h:289

AkAudioBuffer::GetChannel

AkSampleType * GetChannel(AkUInt32 in_uIndex)

Definition: AkCommonDefs.h:432

AK_DEFAULT_TOP_Z

#define AK_DEFAULT_TOP_Z

Definition: AkCommonDefs.h:230

AkUInt16

uint16_t AkUInt16

Unsigned 16-bit integer

Definition: AkNumeralTypes.h:37

Definition of data structures for AkAudioObject

Definition: AkWwiseSDKVersion.cs:31

AkAudioBuffer::HasData

AkForceInline bool HasData() const

Check if buffer has samples attached to it.

Definition: AkCommonDefs.h:397

Ak3DAudioSinkCapabilities

Definition: AkCommonDefs.h:286

AkChannelConfig::HasCenter

AkForceInline bool HasCenter() const

Definition: AkSpeakerConfig.h:644

AkBehavioralPositioningData::center

AkReal32 center

Center percentage [0,1]

Definition: AkCommonDefs.h:265

Ak3dData::Ak3dData

Ak3dData()

Definition: AkCommonDefs.h:237

AkAudioBuffer::GetChannelConfig

AkForceInline AkChannelConfig GetChannelConfig() const

Definition: AkCommonDefs.h:359

AkBehavioralPositioningData::panSpatMix

AkReal32 panSpatMix

Panning vs 3D spatialization mix ([0,1], 1 being 100% spatialized).

Definition: AkCommonDefs.h:269

Ak3DAudioSinkCapabilities::bMultiChannelObjects

bool bMultiChannelObjects

Can handle multi-channel objects

Definition: AkCommonDefs.h:291

AkAudioBuffer::AkAudioBuffer

AkAudioBuffer()

Constructor.

Definition: AkCommonDefs.h:325

Ak3DAudioSinkCapabilities::uMaxSystemAudioObjects

AkUInt32 uMaxSystemAudioObjects

Maximum number of System Audio Objects that can be active concurrently. A value of zero indicates the...

Definition: AkCommonDefs.h:288

AkChannelConfig::uNumChannels

AkUInt32 uNumChannels

Number of channels.

Definition: AkSpeakerConfig.h:449

AkAudioBuffer::DetachContiguousDeinterleavedData

AkForceInline void * DetachContiguousDeinterleavedData()

Detach deinterleaved data where channels are contiguous in memory. The address of the buffer is retur...

Definition: AkCommonDefs.h:478

AkAudioBuffer::NumChannels

AkForceInline AkUInt32 NumChannels() const

Get the number of channels.

Definition: AkCommonDefs.h:348

AkAudioBuffer::Clear

AkForceInline void Clear()

Clear members.

Definition: AkCommonDefs.h:338

AkChannelConfig

Definition: AkSpeakerConfig.h:444

AkBitFuncs.h

AK_DEFAULT_LISTENER_FRONT_Y

#define AK_DEFAULT_LISTENER_FRONT_Y

Definition: AkCommonDefs.h:226

AKRESULT

Standard function call result.

Definition: AkTypes.h:134

AkChannelConfig::uChannelMask

AkUInt32 uChannelMask

Channel mask (configuration).

Definition: AkSpeakerConfig.h:451

AkAudioBuffer::StandardToPipelineIndex

static AkUInt32 StandardToPipelineIndex(AkChannelConfig in_channelConfig, AkUInt32 in_uChannelIdx)

Definition: AkCommonDefs.h:404

AK_ChannelConfigType_Standard

@ AK_ChannelConfigType_Standard

Channels must be identified with standard defines in AkSpeakerConfigs.

Definition: AkSpeakerConfig.h:415

AkAudioFormat::HasCenter

AkForceInline bool HasCenter() const

Definition: AkCommonDefs.h:88

AkTransform::Set

void Set(const AkVector &in_position, const AkVector &in_orientationFront, const AkVector &in_orientationTop)

Set position and orientation. Orientation front and top should be orthogonal and normalized.

Definition: AkTypes.h:578

AkChannelMask

AkUInt32 AkChannelMask

Channel mask (similar to WAVE_FORMAT_EXTENSIBLE). Bit values are defined in AkSpeakerConfig....

Definition: AkTypes.h:81

AkAudioFormat::channelConfig

AkChannelConfig channelConfig

Channel configuration.

Definition: AkCommonDefs.h:63

AK_DEFAULT_LISTENER_POSITION_Z

#define AK_DEFAULT_LISTENER_POSITION_Z

Definition: AkCommonDefs.h:224

AkAudioBuffer::RelocateMedia

void RelocateMedia(AkUInt8 *in_pNewMedia, AkUInt8 *in_pOldMedia)

Definition: AkCommonDefs.h:492

AkUInt8

uint8_t AkUInt8

Unsigned 8-bit integer

Definition: AkNumeralTypes.h:36

AkAudioFormat::uBitsPerSample

AkUInt32 uBitsPerSample

Number of bits per sample.

Definition: AkCommonDefs.h:65

AK_DEFAULT_LISTENER_POSITION_Y

#define AK_DEFAULT_LISTENER_POSITION_Y

Definition: AkCommonDefs.h:223

AkBehavioralPositioningData

Positioning data inherited from sound structures and mix busses.

Definition: AkCommonDefs.h:253

AkAudioFormat::uTypeID

AkUInt32 uTypeID

Data type ID (AkDataTypeID).

Definition: AkCommonDefs.h:67

AK_DEFAULT_TOP_X

#define AK_DEFAULT_TOP_X

Definition: AkCommonDefs.h:228

AkAudioObjectDestination::eDefault

@ eDefault

AK::AkMetering::rms

AK::SpeakerVolumes::VectorPtr rms

Definition: AkCommonDefs.h:203

NULL

#define NULL

Definition: AkTypes.h:46

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:46

AkAudioBuffer::eState

AKRESULT eState

Execution status

Definition: AkCommonDefs.h:507

AK::AkMetering::truePeak

AK::SpeakerVolumes::VectorPtr truePeak

Definition: AkCommonDefs.h:199

AkBehavioralPositioningData::panDU

AkReal32 panDU

Pan down-up [-1,1]

Definition: AkCommonDefs.h:268

AkAudioBuffer::uValidFrames

AkUInt16 uValidFrames

Number of valid sample frames in the audio buffer

Definition: AkCommonDefs.h:513

AkUIntPtr

uintptr_t AkUIntPtr

Integer (unsigned) type for pointers

Definition: AkNumeralTypes.h:50

Ak3dData

Definition: AkCommonDefs.h:236

AK_DEFAULT_TOP_Y

#define AK_DEFAULT_TOP_Y

Definition: AkCommonDefs.h:229

AK::SpeakerVolumes::VectorPtr

AkReal32 * VectorPtr

Volume vector. Access each element with the standard bracket [] operator.

Definition: AkSpeakerVolumes.h:49

AkAudioBuffer::pData

void * pData

Start of the audio buffer.

Definition: AkCommonDefs.h:503

AkAudioObjectDestination

Enum of the possible object destinations when reaching a 3D audio-capable sink

Definition: AkCommonDefs.h:296

AkAudioBuffer::channelConfig

AkChannelConfig channelConfig

Channel config.

Definition: AkCommonDefs.h:504

Ak3DSpatializationMode

3D spatialization mode.

Definition: AkTypes.h:1160

AK::AkMetering::fMeanPowerK

AkReal32 fMeanPowerK

Definition: AkCommonDefs.h:207

AK_DEFAULT_LISTENER_POSITION_X

#define AK_DEFAULT_LISTENER_POSITION_X

Default listener transform.

Definition: AkCommonDefs.h:222

AK_FLOAT

const AkDataTypeID AK_FLOAT

Float data type

Definition: AkCommonDefs.h:48

AkDataTypeID

AkUInt16 AkDataTypeID

Data sample type ID

Definition: AkTypes.h:69

AKASSERT

#define AKASSERT(Condition)

Definition: AkAssert.h:67

AkBehavioralPositioningData::panType

AkSpeakerPanningType panType

Speaker panning type.

Definition: AkCommonDefs.h:271

AKCODECID_BANK_BUS

#define AKCODECID_BANK_BUS

Bank encoding for bus banks. These banks are contained in the /bus sub-folder.

Definition: AkTypes.h:1034

AK_LE_NATIVE_BITSPERSAMPLE

const AkUInt32 AK_LE_NATIVE_BITSPERSAMPLE

Native number of bits per sample.

Definition: AkCommonDefs.h:54

Ak3DAudioSinkCapabilities::bPassthrough

bool bPassthrough

Separate pass-through mix is supported.

Definition: AkCommonDefs.h:290

AkAudioBuffer::uMaxFrames

AkUInt16 uMaxFrames

Number of sample frames the buffer can hold. Access through AkAudioBuffer::MaxFrames().

Definition: AkCommonDefs.h:510

AkPositioningData::behavioral

AkBehavioralPositioningData behavioral

Positioning data inherited from sound structures and mix busses.

Definition: AkCommonDefs.h:279

AkChannelConfig::Clear

AkForceInline void Clear()

Clear the channel config. Becomes "invalid" (IsValid() returns false).

Definition: AkSpeakerConfig.h:503

AkSampleType

AkReal32 AkSampleType

Audio sample data type (32 bit floating point)

Definition: AkCommonDefs.h:314

AK_LE_NATIVE_SAMPLETYPE

const AkUInt32 AK_LE_NATIVE_SAMPLETYPE

Native data type.

Definition: AkCommonDefs.h:55

AK_DEFAULT_LISTENER_FRONT_X

#define AK_DEFAULT_LISTENER_FRONT_X

Definition: AkCommonDefs.h:225

AkBehavioralPositioningData::AkBehavioralPositioningData

AkBehavioralPositioningData()

Definition: AkCommonDefs.h:254

AkPositioningData::threeD

Ak3dData threeD

3D data used for 3D spatialization.

Definition: AkCommonDefs.h:278

AK::GetNumNonZeroBits

AkForceInline AkUInt32 GetNumNonZeroBits(AkUInt32 in_uWord)

Definition: AkBitFuncs.h:197

AK::AkMetering

Struct containing metering information about a buffer. Depending on when this struct is generated,...

Definition: AkCommonDefs.h:192

AkAudioFormat::GetBitsPerSample

AkForceInline AkUInt32 GetBitsPerSample() const

Definition: AkCommonDefs.h:95

AK_DataNeeded

@ AK_DataNeeded

The consumer needs more.

Definition: AkTypes.h:160

AkPositioningData

Positioning data of 3D audio objects.

Definition: AkCommonDefs.h:277

AKCODECID_BANK_EVENT

#define AKCODECID_BANK_EVENT

Bank encoding for event banks. These banks are contained in the /event sub-folder.

Definition: AkTypes.h:1033

AkAudioFormat::uBlockAlign

AkUInt32 uBlockAlign

Number of bytes per sample frame. (For example a 5.1 PCM 16bit should have a uBlockAlign equal to 6(5...

Definition: AkCommonDefs.h:66

Ak3DAudioSinkCapabilities::channelConfig

AkChannelConfig channelConfig

Channel configuration of the main mix.

Definition: AkCommonDefs.h:287

AkAudioFormat::GetInterleaveID

AkForceInline AkUInt32 GetInterleaveID() const

Definition: AkCommonDefs.h:116

AK_DEFAULT_LISTENER_FRONT_Z

#define AK_DEFAULT_LISTENER_FRONT_Z

Definition: AkCommonDefs.h:227

AkAudioFormat::operator!=

AkForceInline bool operator!=(const AkAudioFormat &in_other) const

Definition: AkCommonDefs.h:150

AKCODECID_BANK

#define AKCODECID_BANK

Bank encoding

Definition: AkTypes.h:1011

AkAudioBuffer::ZeroPadToMaxFrames

void ZeroPadToMaxFrames()

Definition: AkCommonDefs.h:454

AkAudioFormat::HasLFE

AkForceInline bool HasLFE() const

Definition: AkCommonDefs.h:79

AK_SpatializationMode_None

@ AK_SpatializationMode_None

No spatialization

Definition: AkTypes.h:1161

AkAudioFormat::GetBlockAlign

AkForceInline AkUInt32 GetBlockAlign() const

Definition: AkCommonDefs.h:102

Ak3dData::uEmitterChannelMask

AkChannelMask uEmitterChannelMask

Emitter channel mask. With 3D spatialization, zeroed channels should be dropped.

Definition: AkCommonDefs.h:248

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkNumeralTypes.h:38

AkChannelMappingFunc

AkUInt8(* AkChannelMappingFunc)(const AkChannelConfig &config, AkUInt8 idx)

Definition: AkCommonDefs.h:161

AkSpeakerPanningType

Speaker panning type: type of panning logic when object is not 3D spatialized (i.e....

Definition: AkTypes.h:1123

AkChannelConfig::eConfigType

AkUInt32 eConfigType

Channel config type (AkChannelConfigType).

Definition: AkSpeakerConfig.h:450

AkBehavioralPositioningData::panLR

AkReal32 panLR

Pan left-right [-1,1]

Definition: AkCommonDefs.h:266

AkAudioBuffer::AttachContiguousDeinterleavedData

AkForceInline void AttachContiguousDeinterleavedData(void *in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig)

Attach deinterleaved data where channels are contiguous in memory. Allocation is performed outside.

Definition: AkCommonDefs.h:473

AkAudioBuffer

Definition: AkCommonDefs.h:321

Ak3dData::spread

AkReal32 spread

Spread [0,1]

Definition: AkCommonDefs.h:246

AkChannelConfig::HasLFE

AkForceInline bool HasLFE() const

Definition: AkSpeakerConfig.h:635

AkAudioFormat::operator==

AkForceInline bool operator==(const AkAudioFormat &in_other) const

Definition: AkCommonDefs.h:140

AkAudioBuffer::GetLFE

AkSampleType * GetLFE()

Definition: AkCommonDefs.h:444

AkAudioBuffer::GetInterleavedData

AkForceInline void * GetInterleavedData()

Definition: AkCommonDefs.h:370

AkAudioFormat::GetNumChannels

AkForceInline AkUInt32 GetNumChannels() const

Definition: AkCommonDefs.h:72

AK_SPEAKER_LOW_FREQUENCY

#define AK_SPEAKER_LOW_FREQUENCY

Low-frequency speaker bit mask

Definition: AkSpeakerConfig.h:38

AkSpeakerConfig.h

AK::IsBankCodecID

static bool IsBankCodecID(AkUInt32 in_codecID)

Definition: AkCommonDefs.h:210

AK_INT

const AkDataTypeID AK_INT

Integer data type (uchar, short, and so on)

Definition: AkCommonDefs.h:47

AkForceInline

#define AkForceInline

Definition: AkTypes.h:63

AkAudioFormat

Defines the parameters of an audio buffer format.

Definition: AkCommonDefs.h:60

AkAudioFormat::uInterleaveID

AkUInt32 uInterleaveID

Interleave ID (AkDataInterleaveID).

Definition: AkCommonDefs.h:68

AkAudioBuffer::CheckValidSamples

bool CheckValidSamples()

AkTransform

Position and orientation of objects in a "local" space

Definition: AkTypes.h:549

AkAudioFormat::GetTypeID

AkForceInline AkUInt32 GetTypeID() const

Definition: AkCommonDefs.h:109

AkChannelConfig::IsValid

AkForceInline bool IsValid() const

Returns true if valid, false otherwise (as when it is constructed, or invalidated using Clear()).

Definition: AkSpeakerConfig.h:570

Ak3dData::focus

AkReal32 focus

Focus [0,1]

Definition: AkCommonDefs.h:247

Ak3dData::xform

AkTransform xform

Object position / orientation.

Definition: AkCommonDefs.h:245

AkAudioBuffer::ClearData

AkForceInline void ClearData()

Clear data pointer.

Definition: AkCommonDefs.h:331

AkAudioBuffer::AttachInterleavedData

void AttachInterleavedData(void *in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames)

Attach interleaved data. Allocation is performed outside.

Definition: AkCommonDefs.h:376

AkAudioFormat::uSampleRate

AkUInt32 uSampleRate

Number of samples per second

Definition: AkCommonDefs.h:61

AK::AkMetering::peak

AK::SpeakerVolumes::VectorPtr peak

Definition: AkCommonDefs.h:195

AK_NONINTERLEAVED

const AkDataInterleaveID AK_NONINTERLEAVED

Non-interleaved data

Definition: AkCommonDefs.h:51

AkBehavioralPositioningData::spatMode

Ak3DSpatializationMode spatMode

3D spatialization mode.

Definition: AkCommonDefs.h:270

AkBehavioralPositioningData::panBF

AkReal32 panBF

Pan back-front [-1,1]

Definition: AkCommonDefs.h:267

AK_INTERLEAVED

const AkDataInterleaveID AK_INTERLEAVED

Interleaved data

Definition: AkCommonDefs.h:50

AkAudioBuffer::AttachInterleavedData

void AttachInterleavedData(void *in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig)

Attach interleaved data with a new channel config. Allocation is performed outside.

Definition: AkCommonDefs.h:384

AkAudioFormat::SetAll

void SetAll(AkUInt32 in_uSampleRate, AkChannelConfig in_channelConfig, AkUInt32 in_uBitsPerSample, AkUInt32 in_uBlockAlign, AkUInt32 in_uTypeID, AkUInt32 in_uInterleaveID)

Definition: AkCommonDefs.h:123

AK_LE_NATIVE_INTERLEAVE

const AkUInt32 AK_LE_NATIVE_INTERLEAVE

Native interleaved setting.

Definition: AkCommonDefs.h:56

AkAudioBuffer::MaxFrames

AkForceInline AkUInt16 MaxFrames() const

Definition: AkCommonDefs.h:500