_ak_common_defs_8h

Wwise SDK 2022.1.11

 /*******************************************************************************
 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/SoundEngine/Common/IAkPluginMemAlloc.h>
 #include <AK/Tools/Common/AkArray.h>
 #include <AK/Tools/Common/AkString.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,     ///< Block alignment
         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);
  
 enum AkSourceChannelOrdering
 {
     SourceChannelOrdering_Standard = 0, // SMPTE L-R-C-LFE-RL-RR-RC-SL-SR-HL-HR-HC-HRL-HRR-HRC-T
     // or ACN ordering + SN3D norm
  
     SourceChannelOrdering_Film, // L/C/R/Ls/Rs/Lfe
     SourceChannelOrdering_FuMa
 };
  
 #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)    ((AkSourceChannelOrdering)(_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(0xffff)
     {
         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.
 };
  
 // Forward defines
 namespace AK
 {
     class IAkPluginParam;
 }
  
 /// An audio object refers to an audio signal with some attached metadata going through the sound engine pipeline.
 /// The AkAudioObject struct encapsulates the metadata part. The signal itself is contained in a separate AkAudioBuffer instance.
 struct AkAudioObject
 {
     /// Constructor
     AkAudioObject()
         :key(AK_INVALID_AUDIO_OBJECT_ID)
         ,cumulativeGain(1.f, 1.f)
         ,instigatorID(AK_INVALID_PIPELINE_ID)
         ,priority(AK_DEFAULT_PRIORITY)
     {}
  
     /// Destructor
     ~AkAudioObject()
     {
         arCustomMetadata.Term();
         objectName.Term();
     }
  
     AkAudioObjectID key;            ///< Unique ID, local to a given bus.
  
     AkPositioningData positioning;  ///< Positioning data for deferred 3D rendering.
     AkRamp cumulativeGain;          ///< Cumulative ramping gain to apply when mixing down to speaker bed or final endpoint
  
     /// Custom object metadata.
     struct CustomMetadata
     {
         AkPluginID pluginID;        ///< Full plugin ID, including company ID and plugin type. See AKMAKECLASSID macro.
         AK::IAkPluginParam* pParam; ///< Custom, pluggable medata.  Note: any custom metadata is expected to exist for only the current sound engine render tick, and persistent references to it should not be stored.
         AkUniqueID contextID;       ///< (Profiling) ID of the sound or bus from which the custom metadata was fetched.
     };
  
     /// Array type for carrying custom metadata.
     class ArrayCustomMetadata : public AkArray<CustomMetadata, const CustomMetadata&, AkPluginArrayAllocator>
     {
     public:
         using ArrayType = AkArray<CustomMetadata, const CustomMetadata&, AkPluginArrayAllocator>;
  
         ArrayType::Iterator FindByPluginID(AkPluginID pluginID) const
         {
             for (auto it = Begin(); it != End(); ++it)
             {
                 if ((*it).pluginID == pluginID)
                     return it;
             }
             return End();
         }
     };
  
     ArrayCustomMetadata arCustomMetadata;   ///< Array of custom metadata, gathered from visited objects. Note: any custom metadata is expected to exist for only the current sound engine render tick, and persistent references to it should not be stored.
  
     AkPipelineID instigatorID;      ///< Profiling ID of the node from which the object stems (typically the voice, instance of an actor-mixer).
  
     typedef AkString<AkPluginArrayAllocator, char> String;  ///< String type for use in 3D audio objects.
     String objectName;              ///< Name string of the object, to appear in the object profiler. This is normally used by out-of-place object processors for naming their output objects. Built-in sound engine structures don't use it.
  
     AkPriority priority;            ///< Audio object playback priority. Object with a higher priority will be rendered using the hardware's object functionality on platforms that supports it, whereas objects with a lower priority will be downmixed to a lower resolution 3D bed. Audio object priorities should be retrieved, or set through IAkPluginServiceAudioObjectPriority to retain compatibility with future Wwise releases.
  
     /// Copy object metadata (everything but the key) from another object.
     void CopyContents(
         const AkAudioObject& in_src ///< Object from which metadata is copied.
     )
     {
         positioning = in_src.positioning;
         cumulativeGain = in_src.cumulativeGain;
         arCustomMetadata.Copy(in_src.arCustomMetadata);
         instigatorID = in_src.instigatorID;
         objectName = in_src.objectName; // AkString performs a shallow copy when it can, like here.
         priority = in_src.priority;
     }
  
     void SetCustomMetadata(CustomMetadata* in_aCustomMetadata, AkUInt32 in_uLength)
     {
         if (arCustomMetadata.Resize(in_uLength))
         {
             for (int i = 0; i < (int)in_uLength; ++i)
             {
                 arCustomMetadata[i] = in_aCustomMetadata[i];
             }
         }
     }
  
     /// Transfer function for transfer move policies.
     void Transfer(
         AkAudioObject& in_from  ///< Object from which data is transferred.
     )
     {
         key = in_from.key;
         positioning = in_from.positioning;
         cumulativeGain = in_from.cumulativeGain;
         arCustomMetadata.Transfer(in_from.arCustomMetadata);
         instigatorID = in_from.instigatorID;
         objectName.Transfer(in_from.objectName);
         priority = in_from.priority;
     }
  
     /// Object processors may give an explicit name to objects. 
     /// \return AK_Success if the string was allocated successfully, AK_InsufficientMemory otherwise.
     AKRESULT SetName(
         AK::IAkPluginMemAlloc* in_pAllocator,   ///< Memory allocator.
         const char* in_szName                   ///< Null-terminated string to allocate and store on this object.
     )
     {
         objectName.Init(in_pAllocator);
         objectName = in_szName;
         return objectName.AllocCopy();
     }
  
     /// Reset object state in preparation for next frame.
     void ResetState()
     {
         arCustomMetadata.Term(); // Reset custom metadata in preparation for next frame.
         objectName.ClearReference(); // Clear reference to string in preparation for next frame.
     }
 };
  
 /// 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;        ///< 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;  ///< 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;                  ///< Separate  pass-through mix is supported.
     bool            bMultiChannelObjects;          ///< 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 configuration, use ChannelMaskToBufferIndex() 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 )
             {
                 AKPLATFORM::AkMemSet( 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
 };
  
 /// A collection of audio objects. Encapsulates the audio data and metadata of each audio object in separate arrays.
 struct AkAudioObjects
 {
     AkAudioObjects(AkUInt32 in_uNumObjects = 0, AkAudioBuffer** in_ppObjectBuffers = nullptr, AkAudioObject** in_ppObjects = nullptr)
         : uNumObjects(in_uNumObjects)
         , ppObjectBuffers(in_ppObjectBuffers)
         , ppObjects(in_ppObjects)
     {}
  
     AkUInt32 uNumObjects;               ///< Number of audio objects.
     AkAudioBuffer** ppObjectBuffers;    ///< Array of pointers to audio object buffers.
     AkAudioObject** ppObjects;          ///< Array of pointers to audio objects.
 };
  
 #endif // _AK_COMMON_DEFS_H_

AkAudioObject::Transfer

void Transfer(AkAudioObject &in_from)

Transfer function for transfer move policies.

Definition: AkCommonDefs.h:382

AkAudioObject::String

AkString< AkPluginArrayAllocator, char > String

String type for use in 3D audio objects.

Definition: AkCommonDefs.h:352

AkAudioBuffer::HasLFE

AkForceInline bool HasLFE() const

Returns true if there is an LFE channel present.

Definition: AkCommonDefs.h:487

AkBehavioralPositioningData::enableHeightSpread

bool enableHeightSpread

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

Definition: AkCommonDefs.h:283

AkMin

#define AkMin(x1, x2)

Definition: AkPlatformFuncs.h:94

AkSpeakerVolumes.h

AkDataInterleaveID

AkUInt8 AkDataInterleaveID

Data interleaved state ID.

Definition: AkTypes.h:138

AK_DirectSpeakerAssignment

@ AK_DirectSpeakerAssignment

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

Definition: AkTypes.h:1156

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:422

AkAudioBuffer::GetChannel

AkSampleType * GetChannel(AkUInt32 in_uIndex)

Definition: AkCommonDefs.h:565

AK_DEFAULT_TOP_Z

#define AK_DEFAULT_TOP_Z

Definition: AkCommonDefs.h:241

AkUInt16

uint16_t AkUInt16

Unsigned 16-bit integer.

Definition: AkNumeralTypes.h:37

Audiokinetic namespace.

Definition: AkWwiseSDKVersion.cs:31

AkAudioBuffer::HasData

AkForceInline bool HasData() const

Check if buffer has samples attached to it.

Definition: AkCommonDefs.h:530

AkAudioObject::AkAudioObject

AkAudioObject()

Constructor.

Definition: AkCommonDefs.h:304

Ak3DAudioSinkCapabilities

Definition: AkCommonDefs.h:419

AkChannelConfig::HasCenter

AkForceInline bool HasCenter() const

Definition: AkSpeakerConfig.h:697

AkAudioObject::positioning

AkPositioningData positioning

Positioning data for deferred 3D rendering.

Definition: AkCommonDefs.h:320

SourceChannelOrdering_FuMa

@ SourceChannelOrdering_FuMa

Definition: AkCommonDefs.h:171

AkBehavioralPositioningData::center

AkReal32 center

Center percentage [0,1].

Definition: AkCommonDefs.h:276

AkAudioObject::cumulativeGain

AkRamp cumulativeGain

Cumulative ramping gain to apply when mixing down to speaker bed or final endpoint.

Definition: AkCommonDefs.h:321

Ak3dData::Ak3dData

Ak3dData()

Definition: AkCommonDefs.h:248

AkAudioBuffer::GetChannelConfig

AkForceInline AkChannelConfig GetChannelConfig() const

Definition: AkCommonDefs.h:492

AkString::Transfer

void Transfer(AkString< TAlloc, T_CHAR > &in_from)

Definition: AkString.h:108

AkAudioObjectID

AkUInt64 AkAudioObjectID

Audio Object ID.

Definition: AkTypes.h:156

AkArray::Copy

AKRESULT Copy(const AkArray< T, ARG_T, TAlloc, TGrowBy, TMovePolicy > &in_rSource)

Definition: AkArray.h:827

SourceChannelOrdering_Standard

@ SourceChannelOrdering_Standard

Definition: AkCommonDefs.h:167

AkBehavioralPositioningData::panSpatMix

AkReal32 panSpatMix

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

Definition: AkCommonDefs.h:280

Ak3DAudioSinkCapabilities::bMultiChannelObjects

bool bMultiChannelObjects

Can handle multi-channel objects.

Definition: AkCommonDefs.h:424

AkPipelineID

AkUInt32 AkPipelineID

Unique node (bus, voice) identifier for profiling.

Definition: AkTypes.h:154

AkAudioBuffer::AkAudioBuffer

AkAudioBuffer()

Constructor.

Definition: AkCommonDefs.h:458

Ak3DAudioSinkCapabilities::uMaxSystemAudioObjects

AkUInt32 uMaxSystemAudioObjects

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

Definition: AkCommonDefs.h:421

AkString.h

AK::IAkPluginParam

Definition: IAkPlugin.h:619

AkChannelConfig::uNumChannels

AkUInt32 uNumChannels

Number of channels.

Definition: AkSpeakerConfig.h:502

AkAudioObject::key

AkAudioObjectID key

Unique ID, local to a given bus.

Definition: AkCommonDefs.h:318

AkAudioBuffer::DetachContiguousDeinterleavedData

AkForceInline void * DetachContiguousDeinterleavedData()

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

Definition: AkCommonDefs.h:611

AkAudioBuffer::NumChannels

AkForceInline AkUInt32 NumChannels() const

Get the number of channels.

Definition: AkCommonDefs.h:481

AkAudioBuffer::Clear

AkForceInline void Clear()

Clear members.

Definition: AkCommonDefs.h:471

AkChannelConfig

Definition: AkSpeakerConfig.h:497

AK_DEFAULT_LISTENER_FRONT_Y

#define AK_DEFAULT_LISTENER_FRONT_Y

Definition: AkCommonDefs.h:237

AKRESULT

Standard function call result.

Definition: AkTypes.h:199

AkChannelConfig::uChannelMask

AkUInt32 uChannelMask

Channel mask (configuration).

Definition: AkSpeakerConfig.h:504

AkAudioBuffer::StandardToPipelineIndex

static AkUInt32 StandardToPipelineIndex(AkChannelConfig in_channelConfig, AkUInt32 in_uChannelIdx)

Definition: AkCommonDefs.h:537

AK_ChannelConfigType_Standard

@ AK_ChannelConfigType_Standard

Channels must be identified with standard defines in AkSpeakerConfigs.

Definition: AkSpeakerConfig.h:469

AkAudioFormat::HasCenter

AkForceInline bool HasCenter() const

Definition: AkCommonDefs.h:90

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:623

AK_INVALID_AUDIO_OBJECT_ID

static const AkAudioObjectID AK_INVALID_AUDIO_OBJECT_ID

Invalid audio object ID.

Definition: AkTypes.h:177

AkChannelMask

AkUInt32 AkChannelMask

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

Definition: AkTypes.h:149

AkAudioFormat::channelConfig

AkChannelConfig channelConfig

Channel configuration.

Definition: AkCommonDefs.h:65

AK_DEFAULT_LISTENER_POSITION_Z

#define AK_DEFAULT_LISTENER_POSITION_Z

Definition: AkCommonDefs.h:235

SourceChannelOrdering_Film

@ SourceChannelOrdering_Film

Definition: AkCommonDefs.h:170

AkAudioBuffer::RelocateMedia

void RelocateMedia(AkUInt8 *in_pNewMedia, AkUInt8 *in_pOldMedia)

Definition: AkCommonDefs.h:625

AkUInt8

uint8_t AkUInt8

Unsigned 8-bit integer.

Definition: AkNumeralTypes.h:36

AkAudioFormat::uBitsPerSample

AkUInt32 uBitsPerSample

Number of bits per sample.

Definition: AkCommonDefs.h:67

AK_DEFAULT_LISTENER_POSITION_Y

#define AK_DEFAULT_LISTENER_POSITION_Y

Definition: AkCommonDefs.h:234

AkAudioObject::CopyContents

void CopyContents(const AkAudioObject &in_src)

Copy object metadata (everything but the key) from another object.

Definition: AkCommonDefs.h:358

AkBehavioralPositioningData

Positioning data inherited from sound structures and mix busses.

Definition: AkCommonDefs.h:264

AkAudioFormat::uTypeID

AkUInt32 uTypeID

Data type ID (AkDataTypeID).

Definition: AkCommonDefs.h:69

AK_DEFAULT_TOP_X

#define AK_DEFAULT_TOP_X

Definition: AkCommonDefs.h:239

AkAudioObjectDestination::eDefault

@ eDefault

AkArray

Specific implementation of array.

Definition: AkArray.h:241

AK::AkMetering::rms

AK::SpeakerVolumes::VectorPtr rms

Definition: AkCommonDefs.h:214

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:640

AK::AkMetering::truePeak

AK::SpeakerVolumes::VectorPtr truePeak

Definition: AkCommonDefs.h:210

AkBehavioralPositioningData::panDU

AkReal32 panDU

Pan down-up [-1,1].

Definition: AkCommonDefs.h:279

AkAudioBuffer::uValidFrames

AkUInt16 uValidFrames

Number of valid sample frames in the audio buffer.

Definition: AkCommonDefs.h:646

AkUIntPtr

uintptr_t AkUIntPtr

Integer (unsigned) type for pointers.

Definition: AkNumeralTypes.h:50

AK_DEFAULT_PRIORITY

static const AkPriority AK_DEFAULT_PRIORITY

Default sound / I/O priority.

Definition: AkTypes.h:180

Ak3dData

Definition: AkCommonDefs.h:247

AkAudioObject

Definition: AkCommonDefs.h:302

AkAudioObject::SetName

AKRESULT SetName(AK::IAkPluginMemAlloc *in_pAllocator, const char *in_szName)

Definition: AkCommonDefs.h:397

AK_DEFAULT_TOP_Y

#define AK_DEFAULT_TOP_Y

Definition: AkCommonDefs.h:240

AkPluginArrayAllocator::Init

AkForceInline void Init(AK::IAkPluginMemAlloc *in_pAllocator)

Definition: IAkPluginMemAlloc.h:202

AK::IAkPluginMemAlloc

Definition: IAkPluginMemAlloc.h:43

AK::SpeakerVolumes::VectorPtr

AkReal32 * VectorPtr

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

Definition: AkSpeakerVolumes.h:48

AkAudioBuffer::pData

void * pData

Start of the audio buffer.

Definition: AkCommonDefs.h:636

AkAudioObjectDestination

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

Definition: AkCommonDefs.h:429

AkAudioBuffer::channelConfig

AkChannelConfig channelConfig

Channel config.

Definition: AkCommonDefs.h:637

AkUniqueID

AkUInt32 AkUniqueID

Unique 32-bit ID.

Definition: AkTypes.h:120

AkArray::Resize

bool Resize(AkUInt32 in_uiSize)

Resize the array to the specified size.

Definition: AkArray.h:784

AkAudioObjects::ppObjectBuffers

AkAudioBuffer ** ppObjectBuffers

Array of pointers to audio object buffers.

Definition: AkCommonDefs.h:659

Ak3DSpatializationMode

3D spatialization mode.

Definition: AkTypes.h:1189

AK::AkMetering::fMeanPowerK

AkReal32 fMeanPowerK

Definition: AkCommonDefs.h:218

AK_DEFAULT_LISTENER_POSITION_X

#define AK_DEFAULT_LISTENER_POSITION_X

Default listener transform.

Definition: AkCommonDefs.h:233

AK_FLOAT

const AkDataTypeID AK_FLOAT

Float data type.

Definition: AkCommonDefs.h:50

AkPluginID

AkUInt32 AkPluginID

Source or effect plug-in ID.

Definition: AkTypes.h:131

AkString< AkPluginArrayAllocator, char >

AkDataTypeID

AkUInt16 AkDataTypeID

Data sample type ID.

Definition: AkTypes.h:137

AkAudioObject::ResetState

void ResetState()

Reset object state in preparation for next frame.

Definition: AkCommonDefs.h:408

AKASSERT

#define AKASSERT(Condition)

Definition: AkAssert.h:67

AkAudioObjects::uNumObjects

AkUInt32 uNumObjects

Number of audio objects.

Definition: AkCommonDefs.h:658

IAkPluginMemAlloc.h

AkBehavioralPositioningData::panType

AkSpeakerPanningType panType

Speaker panning type.

Definition: AkCommonDefs.h:282

AkAudioObject::arCustomMetadata

ArrayCustomMetadata arCustomMetadata

Array of custom metadata, gathered from visited objects. Note: any custom metadata is expected to exi...

Definition: AkCommonDefs.h:348

AKCODECID_BANK_BUS

#define AKCODECID_BANK_BUS

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

Definition: AkTypes.h:1068

AK_INVALID_PIPELINE_ID

static const AkPipelineID AK_INVALID_PIPELINE_ID

Invalid pipeline ID (for profiling)

Definition: AkTypes.h:176

AK_LE_NATIVE_BITSPERSAMPLE

const AkUInt32 AK_LE_NATIVE_BITSPERSAMPLE

Native number of bits per sample.

Definition: AkCommonDefs.h:56

Ak3DAudioSinkCapabilities::bPassthrough

bool bPassthrough

Separate pass-through mix is supported.

Definition: AkCommonDefs.h:423

AkRamp

Volume ramp specified by end points "previous" and "next".

Definition: AkTypes.h:933

AkAudioBuffer::uMaxFrames

AkUInt16 uMaxFrames

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

Definition: AkCommonDefs.h:643

AkArray< CustomMetadata, const CustomMetadata &, AkPluginArrayAllocator >::End

Iterator End() const

Returns the iterator to the end of the array.

Definition: AkArray.h:335

AkAudioObject::CustomMetadata::pluginID

AkPluginID pluginID

Full plugin ID, including company ID and plugin type. See AKMAKECLASSID macro.

Definition: AkCommonDefs.h:326

AkPriority

AkInt8 AkPriority

Priority.

Definition: AkTypes.h:135

AkPositioningData::behavioral

AkBehavioralPositioningData behavioral

Positioning data inherited from sound structures and mix busses.

Definition: AkCommonDefs.h:290

AkArray.h

AkAudioObject::ArrayCustomMetadata::FindByPluginID

ArrayType::Iterator FindByPluginID(AkPluginID pluginID) const

Definition: AkCommonDefs.h:337

AkChannelConfig::Clear

AkForceInline void Clear()

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

Definition: AkSpeakerConfig.h:556

AkSampleType

AkReal32 AkSampleType

Audio sample data type (32 bit floating point)

Definition: AkCommonDefs.h:447

AkAudioObject::CustomMetadata::pParam

AK::IAkPluginParam * pParam

Custom, pluggable medata. Note: any custom metadata is expected to exist for only the current sound e...

Definition: AkCommonDefs.h:327

AkStringData::ClearReference

void ClearReference()

Definition: AkString.h:49

AK_LE_NATIVE_SAMPLETYPE

const AkUInt32 AK_LE_NATIVE_SAMPLETYPE

Native data type.

Definition: AkCommonDefs.h:57

AK_DEFAULT_LISTENER_FRONT_X

#define AK_DEFAULT_LISTENER_FRONT_X

Definition: AkCommonDefs.h:236

AKPLATFORM::AkMemSet

AkForceInline void AkMemSet(void *pDest, AkInt32 iVal, AkUInt32 uSize)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:410

AkArray::Transfer

void Transfer(AkArray< T, ARG_T, TAlloc, TGrowBy, TMovePolicy > &in_rSource)

Definition: AkArray.h:814

AkAudioObject::instigatorID

AkPipelineID instigatorID

Profiling ID of the node from which the object stems (typically the voice, instance of an actor-mixer...

Definition: AkCommonDefs.h:350

AkBehavioralPositioningData::AkBehavioralPositioningData

AkBehavioralPositioningData()

Definition: AkCommonDefs.h:265

AkArray< CustomMetadata, const CustomMetadata &, AkPluginArrayAllocator >::Begin

Iterator Begin() const

Returns the iterator to the first item of the array, will be End() if the array is empty.

Definition: AkArray.h:327

AkPositioningData::threeD

Ak3dData threeD

3D data used for 3D spatialization.

Definition: AkCommonDefs.h:289

AK::GetNumNonZeroBits

AkForceInline AkUInt32 GetNumNonZeroBits(AkUInt32 in_uWord)

Definition: AkPlatformFuncs.h:122

AK::AkMetering

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

Definition: AkCommonDefs.h:203

AkAudioFormat::GetBitsPerSample

AkForceInline AkUInt32 GetBitsPerSample() const

Definition: AkCommonDefs.h:97

AK_DataNeeded

@ AK_DataNeeded

The consumer needs more.

Definition: AkTypes.h:225

AkPositioningData

Positioning data of 3D audio objects.

Definition: AkCommonDefs.h:288

AkAudioObjects

A collection of audio objects. Encapsulates the audio data and metadata of each audio object in separ...

Definition: AkCommonDefs.h:651

AKCODECID_BANK_EVENT

#define AKCODECID_BANK_EVENT

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

Definition: AkTypes.h:1067

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:68

Ak3DAudioSinkCapabilities::channelConfig

AkChannelConfig channelConfig

Channel configuration of the main mix.

Definition: AkCommonDefs.h:420

AkAudioFormat::GetInterleaveID

AkForceInline AkUInt32 GetInterleaveID() const

Definition: AkCommonDefs.h:118

AK_DEFAULT_LISTENER_FRONT_Z

#define AK_DEFAULT_LISTENER_FRONT_Z

Definition: AkCommonDefs.h:238

AkAudioFormat::operator!=

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

Definition: AkCommonDefs.h:152

AKCODECID_BANK

#define AKCODECID_BANK

Bank encoding.

Definition: AkTypes.h:1045

AkAudioBuffer::ZeroPadToMaxFrames

void ZeroPadToMaxFrames()

Definition: AkCommonDefs.h:587

AkAudioFormat::HasLFE

AkForceInline bool HasLFE() const

Definition: AkCommonDefs.h:81

AK_SpatializationMode_None

@ AK_SpatializationMode_None

No spatialization.

Definition: AkTypes.h:1190

AkAudioFormat::GetBlockAlign

AkForceInline AkUInt32 GetBlockAlign() const

Definition: AkCommonDefs.h:104

AkString::AllocCopy

AKRESULT AllocCopy()

Definition: AkString.h:84

Ak3dData::uEmitterChannelMask

AkChannelMask uEmitterChannelMask

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

Definition: AkCommonDefs.h:259

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer.

Definition: AkNumeralTypes.h:38

AkAudioObject::SetCustomMetadata

void SetCustomMetadata(CustomMetadata *in_aCustomMetadata, AkUInt32 in_uLength)

Definition: AkCommonDefs.h:370

AkChannelMappingFunc

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

Definition: AkCommonDefs.h:163

AkSpeakerPanningType

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

Definition: AkTypes.h:1155

AkChannelConfig::eConfigType

AkUInt32 eConfigType

Channel config type (AkChannelConfigType).

Definition: AkSpeakerConfig.h:503

AkBehavioralPositioningData::panLR

AkReal32 panLR

Pan left-right [-1,1].

Definition: AkCommonDefs.h:277

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:606

AkArray::Term

void Term()

Term the array. Must be called before destroying the object.

Definition: AkArray.h:537

AkAudioBuffer

Definition: AkCommonDefs.h:454

Ak3dData::spread

AkReal32 spread

Spread [0,1].

Definition: AkCommonDefs.h:257

AkChannelConfig::HasLFE

AkForceInline bool HasLFE() const

Definition: AkSpeakerConfig.h:688

AkAudioObject::~AkAudioObject

~AkAudioObject()

Destructor.

Definition: AkCommonDefs.h:312

AkAudioObject::priority

AkPriority priority

Audio object playback priority. Object with a higher priority will be rendered using the hardware's o...

Definition: AkCommonDefs.h:355

AkAudioFormat::operator==

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

Definition: AkCommonDefs.h:142

AkAudioBuffer::GetLFE

AkSampleType * GetLFE()

Definition: AkCommonDefs.h:577

AkAudioBuffer::GetInterleavedData

AkForceInline void * GetInterleavedData()

Definition: AkCommonDefs.h:503

AkAudioObject::objectName

String objectName

Name string of the object, to appear in the object profiler. This is normally used by out-of-place ob...

Definition: AkCommonDefs.h:353

AkAudioObject::CustomMetadata

Custom object metadata.

Definition: AkCommonDefs.h:325

AkAudioFormat::GetNumChannels

AkForceInline AkUInt32 GetNumChannels() const

Definition: AkCommonDefs.h:74

AkStringData::Term

void Term()

Definition: AkString.h:39

AK_SPEAKER_LOW_FREQUENCY

#define AK_SPEAKER_LOW_FREQUENCY

Low-frequency speaker bit mask.

Definition: AkSpeakerConfig.h:36

AkAudioObject::ArrayCustomMetadata

Array type for carrying custom metadata.

Definition: AkCommonDefs.h:333

AkSpeakerConfig.h

AK::IsBankCodecID

static bool IsBankCodecID(AkUInt32 in_codecID)

Definition: AkCommonDefs.h:221

AK_INT

const AkDataTypeID AK_INT

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

Definition: AkCommonDefs.h:49

AkForceInline

#define AkForceInline

Definition: AkTypes.h:63

AkAudioFormat

Defines the parameters of an audio buffer format.

Definition: AkCommonDefs.h:62

AkAudioFormat::uInterleaveID

AkUInt32 uInterleaveID

Interleave ID (AkDataInterleaveID).

Definition: AkCommonDefs.h:70

AkAudioObject::CustomMetadata::contextID

AkUniqueID contextID

(Profiling) ID of the sound or bus from which the custom metadata was fetched.

Definition: AkCommonDefs.h:328

AkAudioBuffer::CheckValidSamples

bool CheckValidSamples()

AkTransform

Position and orientation of objects in a "local" space.

Definition: AkTypes.h:594

AkAudioFormat::GetTypeID

AkForceInline AkUInt32 GetTypeID() const

Definition: AkCommonDefs.h:111

AkChannelConfig::IsValid

AkForceInline bool IsValid() const

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

Definition: AkSpeakerConfig.h:623

Ak3dData::focus

AkReal32 focus

Focus [0,1].

Definition: AkCommonDefs.h:258

Ak3dData::xform

AkTransform xform

Object position / orientation.

Definition: AkCommonDefs.h:256

AkAudioBuffer::ClearData

AkForceInline void ClearData()

Clear data pointer.

Definition: AkCommonDefs.h:464

AkAudioBuffer::AttachInterleavedData

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

Attach interleaved data. Allocation is performed outside.

Definition: AkCommonDefs.h:509

AkAudioObjects::AkAudioObjects

AkAudioObjects(AkUInt32 in_uNumObjects=0, AkAudioBuffer **in_ppObjectBuffers=nullptr, AkAudioObject **in_ppObjects=nullptr)

Definition: AkCommonDefs.h:652

AkAudioObjects::ppObjects

AkAudioObject ** ppObjects

Array of pointers to audio objects.

Definition: AkCommonDefs.h:660

AkAudioFormat::uSampleRate

AkUInt32 uSampleRate

Number of samples per second.

Definition: AkCommonDefs.h:63

AK::AkMetering::peak

AK::SpeakerVolumes::VectorPtr peak

Definition: AkCommonDefs.h:206

AK_NONINTERLEAVED

const AkDataInterleaveID AK_NONINTERLEAVED

Non-interleaved data.

Definition: AkCommonDefs.h:53

AkBehavioralPositioningData::spatMode

Ak3DSpatializationMode spatMode

3D spatialization mode.

Definition: AkCommonDefs.h:281

AkBehavioralPositioningData::panBF

AkReal32 panBF

Pan back-front [-1,1].

Definition: AkCommonDefs.h:278

AK_INTERLEAVED

const AkDataInterleaveID AK_INTERLEAVED

Interleaved data.

Definition: AkCommonDefs.h:52

AkSourceChannelOrdering

Definition: AkCommonDefs.h:166

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:517

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:125

AK_LE_NATIVE_INTERLEAVE

const AkUInt32 AK_LE_NATIVE_INTERLEAVE

Native interleaved setting.

Definition: AkCommonDefs.h:58

AkAudioBuffer::MaxFrames

AkForceInline AkUInt16 MaxFrames() const

Definition: AkCommonDefs.h:633