00001 00002 // 00003 // Copyright (c) 2006 Audiokinetic Inc. / All Rights Reserved 00004 // 00006 00007 // AkCommonDefs.h 00008 00011 00012 00013 #ifndef _AK_COMMON_DEFS_H_ 00014 #define _AK_COMMON_DEFS_H_ 00015 00016 #include <AK/SoundEngine/Common/AkSpeakerConfig.h> 00017 #include <AK/SoundEngine/Common/AkSpeakerVolumes.h> 00018 00019 //----------------------------------------------------------------------------- 00020 // AUDIO DATA FORMAT 00021 //----------------------------------------------------------------------------- 00022 00023 // Per-platform standard/largest setup definitions. 00024 #if defined(AK_71AUDIO) 00025 #define AK_SPEAKER_SETUP_DEFAULT_PLANE (AK_SPEAKER_SETUP_7POINT1) ///< All speakers on the plane, supported on this platform. 00026 #define AK_SUPPORTED_STANDARD_CHANNEL_MASK (AK_SPEAKER_SETUP_ALL_SPEAKERS) ///< Platform supports all standard channels. 00027 #elif defined(AK_LFECENTER) && defined(AK_REARCHANNELS) 00028 #define AK_SPEAKER_SETUP_DEFAULT_PLANE (AK_SPEAKER_SETUP_5POINT1) ///< All speakers on the plane, supported on this platform. 00029 #define AK_SUPPORTED_STANDARD_CHANNEL_MASK (AK_SPEAKER_SETUP_DEFAULT_PLANE) ///< Platform supports 5.1 00030 #elif defined(AK_REARCHANNELS) 00031 #ifdef AK_WII 00032 #define AK_SPEAKER_SETUP_DEFAULT_PLANE (AK_SPEAKER_SETUP_DPL2 | AK_SPEAKER_FRONT_CENTER) ///< All speakers on the plane, supported on this platform. 00033 #else 00034 #define AK_SPEAKER_SETUP_DEFAULT_PLANE (AK_SPEAKER_SETUP_4 | AK_SPEAKER_FRONT_CENTER) ///< All speakers on the plane, supported on this platform. 00035 #endif 00036 #define AK_SUPPORTED_STANDARD_CHANNEL_MASK (AK_SPEAKER_SETUP_DEFAULT_PLANE) ///< Most complete speaker configuration supported on this platform. 00037 #else 00038 #define AK_SPEAKER_SETUP_DEFAULT_PLANE (AK_SPEAKER_SETUP_STEREO | AK_SPEAKER_FRONT_CENTER) ///< All speakers on the plane, supported on this platform. 00039 #define AK_SUPPORTED_STANDARD_CHANNEL_MASK (AK_SPEAKER_SETUP_STEREO) ///< Most complete speaker configuration supported on this platform. 00040 #endif 00041 00042 // Channel mask helpers. 00043 namespace AK 00044 { 00047 AkForceInline bool HasLFE( AkChannelMask in_uChannelMask ) 00048 { 00049 return ( in_uChannelMask & AK_SPEAKER_LOW_FREQUENCY ) > 0; 00050 } 00051 00056 AkForceInline bool HasCenter( AkChannelMask in_uChannelMask ) 00057 { 00058 // All supported non-mono configurations have an AK_SPEAKER_FRONT_LEFT. 00059 return ( in_uChannelMask & AK_SPEAKER_FRONT_CENTER ) > 0; 00060 } 00061 00065 AkForceInline AkUInt32 GetNumberOfAnglesForConfig( AkChannelMask in_uChannelMask ) 00066 { 00067 AKASSERT( ( in_uChannelMask & ~AK_SPEAKER_SETUP_DEFAULT_PLANE ) == 0 ); 00068 00069 // LFE is irrelevant. 00070 in_uChannelMask &= ~AK_SPEAKER_LOW_FREQUENCY; 00071 // Center speaker is always in the center and thus does not require an angle. 00072 in_uChannelMask &= ~AK_SPEAKER_FRONT_CENTER; 00073 // We should have complete pairs at this point, unless there is a speaker at 180 degrees, 00074 // in which case we need one more angle to specify it. 00075 AKASSERT( ( in_uChannelMask & AK_SPEAKER_BACK_CENTER ) || ( ( AK::GetNumNonZeroBits( in_uChannelMask ) % 2 ) == 0 ) ); 00076 return AK::GetNumNonZeroBits( in_uChannelMask ) >> 1; 00077 } 00078 } 00079 00080 // Audio data format. 00081 // ------------------------------------------------ 00082 00083 const AkDataTypeID AK_INT = 0; 00084 const AkDataTypeID AK_FLOAT = 1; 00085 00086 const AkDataInterleaveID AK_INTERLEAVED = 0; 00087 const AkDataInterleaveID AK_NONINTERLEAVED = 1; 00088 00089 // Native format currently the same on all supported platforms, may become platform specific in the future 00090 const AkUInt32 AK_LE_NATIVE_BITSPERSAMPLE = 32; 00091 const AkUInt32 AK_LE_NATIVE_SAMPLETYPE = AK_FLOAT; 00092 const AkUInt32 AK_LE_NATIVE_INTERLEAVE = AK_NONINTERLEAVED; 00093 00095 enum AkChannelConfigType 00096 { 00097 AK_ChannelConfigType_Anonymous = 0x0, // Channel mask == 0 and channels are anonymous. 00098 AK_ChannelConfigType_Standard = 0x1, // Channels must be identified with standard defines in AkSpeakerConfigs. 00099 AK_ChannelConfigType_Ambisonic = 0x2 // Ambisonic. Channel mask == 0 and channels follow standard ambisonic order. 00100 }; 00101 00103 struct AkChannelConfig 00104 { 00105 // Channel config: 00106 // - uChannelMask is a bit field, whose channel identifiers depend on AkChannelConfigType (up to 20). Channel bits are defined in AkSpeakerConfig.h. 00107 // - eConfigType is a code that completes the identification of channels by uChannelMask. 00108 // - uNumChannels is the number of channels, identified (deduced from channel mask) or anonymous (set directly). 00109 AkUInt32 uNumChannels :8; 00110 AkUInt32 eConfigType :4; 00111 AkUInt32 uChannelMask :20; 00112 00114 AkForceInline AkChannelConfig() 00115 : uNumChannels( 0 ) 00116 , eConfigType( 0 ) 00117 , uChannelMask( 0 ) 00118 { 00119 } 00120 00122 AkForceInline AkChannelConfig( AkChannelMask in_uChannelMask ) 00123 { 00124 SetStandard( in_uChannelMask ); 00125 } 00126 00128 AkForceInline bool operator!=( AkUInt32 in_uBitField ) 00129 { 00130 return ( *((AkUInt32*)this) != in_uBitField ); 00131 } 00132 00134 AkForceInline void Clear() 00135 { 00136 uNumChannels = 0; 00137 eConfigType = 0; 00138 uChannelMask = 0; 00139 } 00140 00142 AkForceInline void SetStandard( AkUInt32 in_uChannelMask ) 00143 { 00144 uNumChannels = AK::GetNumNonZeroBits( in_uChannelMask ); 00145 eConfigType = AK_ChannelConfigType_Standard; 00146 uChannelMask = in_uChannelMask; 00147 } 00148 00150 AkForceInline void SetStandardOrAnonymous( AkUInt32 in_uNumChannels, AkUInt32 in_uChannelMask ) 00151 { 00152 AKASSERT( in_uChannelMask == 0 || in_uNumChannels == AK::GetNumNonZeroBits( in_uChannelMask ) ); 00153 uNumChannels = in_uNumChannels; 00154 eConfigType = ( in_uChannelMask ) ? AK_ChannelConfigType_Standard : AK_ChannelConfigType_Anonymous; 00155 uChannelMask = in_uChannelMask; 00156 } 00157 00159 AkForceInline void SetAnonymous( AkUInt32 in_uNumChannels ) 00160 { 00161 uNumChannels = in_uNumChannels; 00162 eConfigType = AK_ChannelConfigType_Anonymous; 00163 uChannelMask = 0; 00164 } 00165 00167 AkForceInline void SetAmbisonic( AkUInt32 in_uNumChannels ) 00168 { 00169 uNumChannels = in_uNumChannels; 00170 eConfigType = AK_ChannelConfigType_Ambisonic; 00171 uChannelMask = 0; 00172 } 00173 00175 AkForceInline bool IsValid() 00176 { 00177 return uNumChannels != 0; 00178 } 00179 00181 AkForceInline void Serialize( AkUInt32 & out_uChannelConfig ) const 00182 { 00183 out_uChannelConfig = uNumChannels | ( eConfigType << 8 ) | ( uChannelMask << 12 ); 00184 } 00185 00187 AkForceInline void Deserialize( AkUInt32 in_uChannelConfig ) 00188 { 00189 uNumChannels = in_uChannelConfig & 0x000000ff; 00190 eConfigType = ( in_uChannelConfig >> 8 ) & 0x0000000f; 00191 uChannelMask = ( in_uChannelConfig >> 12 ) & 0x000fffff; 00192 } 00193 00195 AkForceInline AkChannelConfig RemoveLFE() const 00196 { 00197 AkChannelConfig newConfig = *this; 00198 #ifdef AK_LFECENTER 00199 AkUInt32 uNewChannelMask = newConfig.uChannelMask & ~AK_SPEAKER_LOW_FREQUENCY; 00200 AkUInt32 uNumLFEChannel = ( newConfig.uChannelMask - uNewChannelMask ) >> 3; // 0 or 1 00201 AKASSERT( uNumLFEChannel == 0 || uNumLFEChannel == 1 ); 00202 newConfig.uNumChannels -= uNumLFEChannel; 00203 newConfig.uChannelMask = uNewChannelMask; 00204 #endif 00205 return newConfig; 00206 } 00207 00209 AkForceInline AkChannelConfig RemoveCenter() const 00210 { 00211 AkChannelConfig newConfig = *this; 00212 #ifdef AK_LFECENTER 00213 AkUInt32 uNewChannelMask = newConfig.uChannelMask & ~AK_SPEAKER_FRONT_CENTER; 00214 AkUInt32 uNumCenterChannel = ( newConfig.uChannelMask - uNewChannelMask ) >> 2; // 0 or 1. 00215 AKASSERT( uNumCenterChannel == 0 || uNumCenterChannel == 1 ); 00216 newConfig.uNumChannels -= uNumCenterChannel; 00217 newConfig.uChannelMask = uNewChannelMask; 00218 #endif 00219 return newConfig; 00220 } 00221 00223 AkForceInline bool operator==( const AkChannelConfig & in_other ) const 00224 { 00225 return uNumChannels == in_other.uNumChannels 00226 && eConfigType == in_other.eConfigType 00227 && uChannelMask == in_other.uChannelMask; 00228 } 00229 00231 AkForceInline bool operator!=( const AkChannelConfig & in_other ) const 00232 { 00233 return uNumChannels != in_other.uNumChannels 00234 || eConfigType != in_other.eConfigType 00235 || uChannelMask != in_other.uChannelMask; 00236 } 00237 00240 AkForceInline bool IsChannelConfigSupported() const 00241 { 00242 if ( eConfigType == AK_ChannelConfigType_Standard ) 00243 { 00244 bool bIsSupported = true; 00245 switch ( uChannelMask ) 00246 { 00247 case AK_SPEAKER_SETUP_MONO: 00248 case AK_SPEAKER_SETUP_STEREO: 00249 #ifdef AK_LFECENTER 00250 case AK_SPEAKER_SETUP_0POINT1: 00251 case AK_SPEAKER_SETUP_1POINT1: 00252 case AK_SPEAKER_SETUP_2POINT1: 00253 case AK_SPEAKER_SETUP_3STEREO: 00254 case AK_SPEAKER_SETUP_3POINT1: 00255 #ifdef AK_REARCHANNELS 00256 case AK_SPEAKER_SETUP_4: 00257 case AK_SPEAKER_SETUP_4POINT1: 00258 case AK_SPEAKER_SETUP_5: 00259 case AK_SPEAKER_SETUP_5POINT1: 00260 #endif 00261 #endif 00262 #ifdef AK_71AUDIO 00263 case AK_SPEAKER_SETUP_7: 00264 case AK_SPEAKER_SETUP_7POINT1: 00265 #endif // AK_71AUDIO 00266 break; 00267 default: 00268 bIsSupported = false; 00269 } 00270 return bIsSupported; 00271 } 00272 else if ( eConfigType == AK_ChannelConfigType_Anonymous ) 00273 { 00274 return true; 00275 } 00276 else 00277 { 00278 // TODO 00279 AKASSERT( eConfigType == AK_ChannelConfigType_Ambisonic ); 00280 return false; 00281 } 00282 } 00283 00286 AkForceInline bool HasLFE() const 00287 { 00288 #ifdef AK_LFECENTER 00289 return AK::HasLFE( uChannelMask ); 00290 #else 00291 return false; 00292 #endif 00293 } 00294 00299 AkForceInline bool HasCenter() const 00300 { 00301 #ifdef AK_LFECENTER 00302 return AK::HasCenter( uChannelMask ); 00303 #else 00304 return false; 00305 #endif 00306 } 00307 }; 00308 00310 struct AkAudioFormat 00311 { 00312 AkUInt32 uSampleRate; 00313 00314 AkChannelConfig channelConfig; 00315 00316 AkUInt32 uBitsPerSample :6; 00317 AkUInt32 uBlockAlign :10; 00318 AkUInt32 uTypeID :2; 00319 AkUInt32 uInterleaveID :1; 00320 00323 AkForceInline AkUInt32 GetNumChannels() const 00324 { 00325 return channelConfig.uNumChannels; 00326 } 00327 00330 AkForceInline bool HasLFE() const 00331 { 00332 return channelConfig.HasLFE(); 00333 } 00334 00339 AkForceInline bool HasCenter() const 00340 { 00341 return channelConfig.HasCenter(); 00342 } 00343 00346 AkForceInline AkUInt32 GetBitsPerSample() const 00347 { 00348 return uBitsPerSample; 00349 } 00350 00353 AkForceInline AkUInt32 GetBlockAlign() const 00354 { 00355 return uBlockAlign; 00356 } 00357 00360 AkForceInline AkUInt32 GetTypeID() const 00361 { 00362 return uTypeID; 00363 } 00364 00367 AkForceInline AkUInt32 GetInterleaveID() const 00368 { 00369 return uInterleaveID; 00370 } 00371 00374 void SetAll( 00375 AkUInt32 in_uSampleRate, 00376 AkChannelConfig in_channelConfig, 00377 AkUInt32 in_uBitsPerSample, 00378 AkUInt32 in_uBlockAlign, 00379 AkUInt32 in_uTypeID, 00380 AkUInt32 in_uInterleaveID 00381 ) 00382 { 00383 uSampleRate = in_uSampleRate; 00384 channelConfig = in_channelConfig; 00385 uBitsPerSample = in_uBitsPerSample; 00386 uBlockAlign = in_uBlockAlign; 00387 uTypeID = in_uTypeID; 00388 uInterleaveID = in_uInterleaveID; 00389 } 00390 00393 AkForceInline bool IsChannelConfigSupported() const 00394 { 00395 return channelConfig.IsChannelConfigSupported(); 00396 } 00397 00398 }; 00399 00400 // Build a 32 bit class identifier based on the Plug-in type, 00401 // CompanyID and PluginID. 00402 // 00403 // Parameters: 00404 // - in_pluginType: A value from enum AkPluginType (4 bits) 00405 // - in_companyID: CompanyID as defined in the Plug-in's XML file (12 bits) 00406 // * 0-63: Reserved for Audiokinetic 00407 // * 64-255: Reserved for clients' in-house Plug-ins 00408 // * 256-4095: Assigned by Audiokinetic to third-party plug-in developers 00409 // - in_pluginID: PluginID as defined in the Plug-in's XML file (16 bits) 00410 // * 0-65535: Set freely by the Plug-in developer 00411 #define AKMAKECLASSID( in_pluginType, in_companyID, in_pluginID ) \ 00412 ( (in_pluginType) + ( (in_companyID) << 4 ) + ( (in_pluginID) << ( 4 + 12 ) ) ) 00413 00414 #define AKGETPLUGINTYPEFROMCLASSID( in_classID ) ( (in_classID) & AkPluginTypeMask ) 00415 #define AKGETCOMPANYIDFROMCLASSID( in_classID ) ( ( (in_classID) & 0x0000FFF0 ) >> 4 ) 00416 #define AKGETPLUGINIDFROMCLASSID( in_classID ) ( ( (in_classID) & 0xFFFF0000 ) >> ( 4 + 12 ) ) 00417 00418 #define CODECID_FROM_PLUGINID AKGETPLUGINIDFROMCLASSID 00419 00420 00421 namespace AK 00422 { 00424 class IAkMetering 00425 { 00426 protected: 00428 virtual ~IAkMetering(){} 00429 00430 public: 00431 00436 virtual AK::SpeakerVolumes::ConstVectorPtr GetPeak() = 0; 00437 00441 virtual AK::SpeakerVolumes::ConstVectorPtr GetTruePeak() = 0; 00442 00447 virtual AK::SpeakerVolumes::ConstVectorPtr GetRMS() = 0; 00448 00452 virtual AkReal32 GetKWeightedPower() = 0; 00453 }; 00454 } 00455 00456 // Audio buffer. 00457 // ------------------------------------------------ 00458 00467 #if defined AK_WII_FAMILY_HW || defined(AK_3DS) 00468 typedef AkInt16 AkSampleType; 00469 #else 00470 typedef AkReal32 AkSampleType; 00471 #endif 00472 00477 class AkAudioBuffer 00478 { 00479 public: 00480 00482 AkAudioBuffer() 00483 { 00484 Clear(); 00485 } 00486 00488 AkForceInline void ClearData() 00489 { 00490 #if !defined(AK_WII_FAMILY_HW) && !defined(AK_3DS) 00491 pData = NULL; 00492 #else 00493 arData[0] = arData[1] = NULL; 00494 #endif 00495 } 00496 00498 AkForceInline void Clear() 00499 { 00500 ClearData(); 00501 uValidFrames = 0; 00502 uMaxFrames = 0; 00503 eState = AK_DataNeeded; 00504 } 00505 00507 00508 00509 AkForceInline AkUInt32 NumChannels() 00510 { 00511 return channelConfig.uNumChannels; 00512 } 00513 00515 AkForceInline bool HasLFE() 00516 { 00517 return channelConfig.HasLFE(); 00518 } 00519 00520 AkForceInline AkChannelConfig GetChannelConfig() const { return channelConfig; } 00521 00523 00525 00526 00527 00528 00529 00530 00531 #if !defined(AK_3DS) && !defined(AK_WII_FAMILY_HW) 00532 AkForceInline void * GetInterleavedData() 00533 { 00534 return pData; 00535 } 00536 00538 inline void AttachInterleavedData( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig ) 00539 { 00540 pData = in_pData; 00541 uMaxFrames = in_uMaxFrames; 00542 uValidFrames = in_uValidFrames; 00543 channelConfig = in_channelConfig; 00544 } 00545 #endif 00546 00547 00549 00550 00552 AkForceInline bool HasData() 00553 { 00554 #if !defined(AK_WII_FAMILY_HW) && !defined(AK_3DS) 00555 return ( NULL != pData ); 00556 #else 00557 return ( NULL != arData[0] ); 00558 #endif 00559 } 00560 00563 static inline AkUInt32 StandardToPipelineIndex( 00564 AkChannelConfig 00565 #ifdef AK_LFECENTER 00566 in_channelConfig 00567 #endif 00568 , AkUInt32 in_uChannelIdx 00569 ) 00570 { 00571 #ifdef AK_LFECENTER 00572 if ( in_channelConfig.HasLFE() ) 00573 { 00574 AKASSERT( in_channelConfig.eConfigType == AK_ChannelConfigType_Standard ); // in_channelConfig.HasLFE() would not have returned true otherwise. 00575 AKASSERT( AK::GetNumNonZeroBits( in_channelConfig.uChannelMask ) ); 00576 AkUInt32 uIdxLFE = AK::GetNumNonZeroBits( ( AK_SPEAKER_LOW_FREQUENCY - 1 ) & in_channelConfig.uChannelMask ); 00577 if ( in_uChannelIdx == uIdxLFE ) 00578 return in_channelConfig.uNumChannels - 1; 00579 else if ( in_uChannelIdx > uIdxLFE ) 00580 return in_uChannelIdx - 1; 00581 } 00582 #endif 00583 return in_uChannelIdx; 00584 } 00585 00595 inline AkSampleType * GetChannel( 00596 AkUInt32 in_uIndex 00597 ) 00598 { 00599 AKASSERT( in_uIndex < NumChannels() ); 00600 #if defined (AK_WII_FAMILY_HW) || defined(AK_3DS) 00601 return (AkSampleType*)arData[in_uIndex]; 00602 #else 00603 return (AkSampleType*)((AkUInt8*)(pData) + ( in_uIndex * sizeof(AkSampleType) * MaxFrames() )); 00604 #endif 00605 } 00606 00611 inline AkSampleType * GetLFE() 00612 { 00613 if ( channelConfig.uChannelMask & AK_SPEAKER_LOW_FREQUENCY ) 00614 return GetChannel( NumChannels()-1 ); 00615 00616 return (AkSampleType*)0; 00617 } 00618 00621 void ZeroPadToMaxFrames() 00622 { 00623 // Zero out all channels. 00624 const AkUInt32 uNumChannels = NumChannels(); 00625 const AkUInt32 uNumZeroFrames = MaxFrames()-uValidFrames; 00626 if ( uNumZeroFrames ) 00627 { 00628 for ( AkUInt32 i = 0; i < uNumChannels; ++i ) 00629 { 00630 AKPLATFORM::AkMemSet( GetChannel(i) + uValidFrames, 0, uNumZeroFrames * sizeof(AkSampleType) ); 00631 } 00632 uValidFrames = MaxFrames(); 00633 } 00634 } 00635 00636 #if !defined(AK_3DS) && !defined(AK_WII_FAMILY_HW) 00637 00638 AkForceInline void AttachContiguousDeinterleavedData( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig ) 00639 { 00640 AttachInterleavedData( in_pData, in_uMaxFrames, in_uValidFrames, in_channelConfig ); 00641 } 00643 AkForceInline void * DetachContiguousDeinterleavedData() 00644 { 00645 uMaxFrames = 0; 00646 uValidFrames = 0; 00647 channelConfig.Clear(); 00648 void * pDataOld = pData; 00649 pData = NULL; 00650 return pDataOld; 00651 } 00652 #endif 00653 00654 #if defined(_DEBUG) && !defined(AK_WII_FAMILY_HW) 00655 bool CheckValidSamples() 00656 { 00657 // Zero out all channels. 00658 const AkUInt32 uNumChannels = NumChannels(); 00659 for ( AkUInt32 i = 0; i < uNumChannels; ++i ) 00660 { 00661 AkSampleType * AK_RESTRICT pfChan = GetChannel(i); 00662 if ( pfChan ) 00663 { 00664 for ( AkUInt32 j = 0; j < uValidFrames; j++ ) 00665 { 00666 AkSampleType fSample = *pfChan++; 00667 if ( fSample > 4.f ) 00668 return false; 00669 else if ( fSample < -4.f ) 00670 return false; 00671 } 00672 } 00673 } 00674 00675 return true; 00676 } 00677 #endif 00678 00679 #ifdef AK_PS3 00680 00681 00682 00683 AkForceInline void * GetDataStartDMA() 00684 { 00685 return pData; 00686 } 00687 #endif 00688 00689 #ifdef __SPU__ 00690 00691 00692 AkForceInline void CreateFromDMA( void * in_pData, AkUInt16 in_uMaxFrames, AkUInt16 in_uValidFrames, AkChannelConfig in_channelConfig, AKRESULT in_eState ) 00693 { 00694 pData = in_pData; 00695 uMaxFrames = in_uMaxFrames; 00696 uValidFrames = in_uValidFrames; 00697 channelConfig = in_channelConfig; 00698 eState = in_eState; 00699 } 00700 #endif 00701 00702 00703 #if !defined(AK_3DS) && !defined(AK_WII_FAMILY_HW) 00704 void RelocateMedia( AkUInt8* in_pNewMedia, AkUInt8* in_pOldMedia ) 00705 { 00706 AkUIntPtr uMemoryOffset = (AkUIntPtr)in_pNewMedia - (AkUIntPtr)in_pOldMedia; 00707 pData = (void*) (((AkUIntPtr)pData) + uMemoryOffset); 00708 } 00709 #endif 00710 00711 protected: 00712 #if defined (AK_WII_FAMILY_HW) || defined(AK_3DS) 00713 void * arData[AK_VOICE_MAX_NUM_CHANNELS]; 00714 #else 00715 void * pData; 00716 #endif 00717 AkChannelConfig channelConfig; 00718 public: 00719 AKRESULT eState; 00720 protected: 00721 AkUInt16 uMaxFrames; 00722 00723 public: 00726 AkForceInline AkUInt16 MaxFrames() { return uMaxFrames; } 00727 00728 AkUInt16 uValidFrames; 00729 } AK_ALIGN_DMA; 00730 00731 #endif // _AK_COMMON_DEFS_H_ 00732
프로젝트를 등록하세요. 아무런 조건이나 의무 사항 없이 빠른 시작을 도와드리겠습니다.
Wwise를 시작해 보세요