_n_x_2_ak_platform_funcs_8h

Other Documentation

Wwise SDK 2022.1.4

 /*******************************************************************************

 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) 2023 Audiokinetic Inc.

 *******************************************************************************/

 #pragma once

 #include <AK/Tools/Common/AkAssert.h>

 #include <AK/SoundEngine/Common/AkTypes.h>

 #include <nn/os.h>

 #include <time.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <wchar.h>

 #define AkMax(x1, x2)   (((x1) > (x2))? (x1): (x2))

 #define AkMin(x1, x2)   (((x1) < (x2))? (x1): (x2))

 #define AkClamp(x, min, max)  ((x) < (min)) ? (min) : (((x) > (max) ? (max) : (x)))

 //-----------------------------------------------------------------------------

 // Platform-specific thread properties definition.

 //-----------------------------------------------------------------------------

 struct AkThreadProperties

 {

     AkInt32 nPriority;              ///< Thread priority. 0=highest, 31=lowest.

     size_t  uStackSize;             ///< Thread stack size.

     int     iIdealCore;             ///< Preferred core number: see nn::os::SetThreadCoreMask documentation.

     nn::Bit64 affinityMask;         ///< Affinity mask for each core: see nn::os::SetThreadCoreMask documentation.

 };

 //-----------------------------------------------------------------------------

 // External variables.

 //-----------------------------------------------------------------------------

 // g_fFreqRatio is used by time helpers to return time values in milliseconds.

 // It is declared and updated by the sound engine.

 namespace AK

 {

     extern AkReal32 g_fFreqRatio;

 }

 #define AK_DECLARE_THREAD_ROUTINE( FuncName )   void FuncName(void* lpParameter)

 #define AK_THREAD_RETURN( _param_ )             return // (_param_)

 #define AK_THREAD_ROUTINE_PARAMETER             lpParameter

 #define AK_GET_THREAD_ROUTINE_PARAMETER_PTR(type) reinterpret_cast<type*>( AK_THREAD_ROUTINE_PARAMETER )

 #define AK_NULL_THREAD                          nullptr

 #define AK_THREAD_PRIORITY_NORMAL               (nn::os::DefaultThreadPriority)

 #define AK_THREAD_PRIORITY_ABOVE_NORMAL         (nn::os::DefaultThreadPriority-1)

 #define AK_THREAD_PRIORITY_BELOW_NORMAL         (nn::os::LowestThreadPriority)

 #define AK_DEFAULT_STACK_SIZE                   (128*1024)

 #define AK_VM_PAGE_SIZE                         (nn::os::MemoryPageSize)

 #define AK_INFINITE                             (-1)

 namespace AKPLATFORM

 {

     // Simple automatic event API

     // ------------------------------------------------------------------

     /// Platform Independent Helper

     AkForceInline void AkClearEvent(AkEvent &out_event)

     {

         memset(&out_event, 0, sizeof(out_event));

     }

     /// Platform Independent Helper

     AkForceInline AKRESULT AkCreateEvent(AkEvent & out_event)

     {

         nn::os::InitializeEvent(&out_event, false, nn::os::EventClearMode_AutoClear);

         return AK_Success;

     }

     /// Platform Independent Helper

     AkForceInline void AkDestroyEvent(AkEvent & io_event)

     {

         if (io_event._state == nn::os::EventType::State_Initialized)

             nn::os::FinalizeEvent(&io_event);

     }

     /// Platform Independent Helper

     AkForceInline void AkWaitForEvent(AkEvent & in_event)

     {

         AKASSERT(in_event._state == nn::os::EventType::State_Initialized);

         nn::os::WaitEvent(&in_event);

     }

     /// Platform Independent Helper

     AkForceInline void AkSignalEvent(AkEvent & in_event)

     {

         AKASSERT(in_event._state == nn::os::EventType::State_Initialized);

         nn::os::SignalEvent(&in_event);

     }

     /// Platform Independent Helper

     AkForceInline void AkClearSemaphore(AkSemaphore& io_semaphore)

     {

         memset(&io_semaphore, 0, sizeof(AkSemaphore));

     }

     /// Platform Independent Helper

     inline AKRESULT AkCreateSemaphore( AkSemaphore & out_semaphore, AkUInt32 in_initialCount )

     {

         nn::os::InitializeSemaphore(    

                             &out_semaphore,

                             in_initialCount,

                             INT_MAX );

         return AK_Success;

     }

     /// Platform Independent Helper

     inline void AkDestroySemaphore(AkSemaphore & io_semaphore)

     {

         AKASSERT(io_semaphore._state == nn::os::SemaphoreType::State_Initialized);

         nn::os::FinalizeSemaphore(&io_semaphore);

     }

     /// Platform Independent Helper - Semaphore wait, aka Operation P. Decrements value of semaphore, and, if the semaphore would be less than 0, waits for the semaphore to be released.

     inline void AkWaitForSemaphore(AkSemaphore & in_semaphore)

     {

         AKASSERT(in_semaphore._state == nn::os::SemaphoreType::State_Initialized);

         nn::os::AcquireSemaphore(&in_semaphore);

     }

     /// Platform Independent Helper - Semaphore signal, aka Operation V. Increments value of semaphore by an arbitrary count.

     inline void AkReleaseSemaphore(AkSemaphore& in_semaphore, AkUInt32 in_count)

     {

         AKASSERT(in_semaphore._state == nn::os::SemaphoreType::State_Initialized);

         nn::os::ReleaseSemaphore(&in_semaphore, in_count);

     }

     // Virtual Memory

     // ------------------------------------------------------------------

     // On NX, virtual memory is OFF by default (and unavailable on NX32) : use aligned heap alloc for "VM" page allocations.

     //AkForceInline void* AllocVM(size_t size, size_t* extra)

     //{

     //  size = (size + nn::os::MemoryPageSize - 1) / nn::os::MemoryPageSize * nn::os::MemoryPageSize;

     //  uintptr_t region;

     //  auto result = nn::os::AllocateAddressRegion(&region, size);

     //  if (result.IsFailure())

     //  {

     //      // Allocation of address space fails.

     //      return nullptr;

     //  }

     //  result = nn::os::AllocateMemoryPages(region, size);

     //  if (result.IsFailure())

     //  {

     //      // Allocation of physical memory fails.

     //      return nullptr;

     //  }

     //  return reinterpret_cast<void *>(region);

     //}

     //AkForceInline void FreeVM(void* address, size_t size, size_t extra, size_t release)

     //{

     //  if (release)

     //  {

     //      auto result = nn::os::FreeAddressRegion(reinterpret_cast<uintptr_t>(address));

     //      AKASSERT(!result.IsFailure());

     //      {

     //          // Freeing fails.

     //          return;

     //      }

     //  }

     //}

     AkForceInline void* AllocVM(size_t size, size_t* /*extra*/)

     {

         return aligned_alloc(nn::os::MemoryPageSize, size);

     }

     AkForceInline void FreeVM(void* address, size_t /*size*/, size_t /*extra*/, size_t release)

     {

         if (release)

         {

             free(address);

         }

     }

     // Threads

     // ------------------------------------------------------------------

     /// Platform Independent Helper

     AkForceInline bool AkIsValidThread(AkThread * in_pThread)

     {

         return in_pThread->thread._state != nn::os::ThreadType::State_NotInitialized;

     }

     /// Platform Independent Helper

     AkForceInline void AkClearThread(AkThread * in_pThread)

     {

         in_pThread->thread._state = nn::os::ThreadType::State_NotInitialized;

     }

     /// Platform Independent Helper

     AkForceInline void AkCloseThread(AkThread * in_pThread)

     {

         nn::os::DestroyThread(&in_pThread->thread);

         FreeVM((void *)in_pThread->pStackAlloc, in_pThread->uStackSize, 1, in_pThread->sizExtra);

         in_pThread->pStackAlloc = nullptr;

     }

 #define AkExitThread( _result ) return

     /// Platform Independent Helper

     AkForceInline void AkGetDefaultThreadProperties(AkThreadProperties & out_threadProperties)

     {

         out_threadProperties.nPriority = AK_THREAD_PRIORITY_NORMAL;

         out_threadProperties.uStackSize = AK_DEFAULT_STACK_SIZE;

         out_threadProperties.iIdealCore = nn::os::IdealCoreUseDefaultValue;

         out_threadProperties.affinityMask = 0; // ignored when iIdealCore == nn::os::IdealCoreUseDefaultValue

     }

     /// Platform Independent Helper

     AkForceInline void AkCreateThread(

         AkThreadRoutine pStartRoutine,                  // Thread routine.

         void * in_pParams,                              // Routine params.

         const AkThreadProperties & in_threadProperties, // Properties.

         AkThread * out_pThread,                         // Returned thread handle.

         const char * in_szThreadName)                   // Opt thread name.

     {

         AKASSERT(out_pThread != NULL);

         AKASSERT(in_threadProperties.uStackSize > 0);

         AKASSERT(in_threadProperties.nPriority >= nn::os::HighestThreadPriority  && in_threadProperties.nPriority <= nn::os::LowestThreadPriority);

         out_pThread->pStackAlloc = (AkUInt8 *)AllocVM(in_threadProperties.uStackSize, &out_pThread->sizExtra);

         if (!out_pThread->pStackAlloc)

             return;

         out_pThread->uStackSize = in_threadProperties.uStackSize;

         nn::Result result;

         result = nn::os::CreateThread(&out_pThread->thread, pStartRoutine, in_pParams, out_pThread->pStackAlloc, out_pThread->uStackSize, in_threadProperties.nPriority);

         if (!result.IsSuccess())

         {

             FreeVM((void *)out_pThread->pStackAlloc, out_pThread->uStackSize, out_pThread->uStackSize, out_pThread->sizExtra);

             out_pThread->pStackAlloc = nullptr;

             return;

         }

         if (in_szThreadName)

         {

             nn::os::SetThreadName(&out_pThread->thread, in_szThreadName);

         }

         nn::os::SetThreadCoreMask(&out_pThread->thread, in_threadProperties.iIdealCore, in_threadProperties.affinityMask);

         nn::os::StartThread(&out_pThread->thread);

     }

     /// Platform Independent Helper

     AkForceInline void AkWaitForSingleThread(AkThread * in_pThread)

     {

         nn::os::WaitThread(&in_pThread->thread);

     }

     AkForceInline AkThreadID CurrentThread()

     {

         return nn::os::GetCurrentThread();

     }

     /// Platform Independent Helper

     AkForceInline void AkSleep(AkUInt32 in_ulMilliseconds)

     {

         nn::os::SleepThread(nn::TimeSpan::FromMilliSeconds(in_ulMilliseconds));

     }

     // Optimized memory functions

     // --------------------------------------------------------------------

     /// Platform Independent Helper

     AkForceInline void AkMemCpy( void * pDest, const void * pSrc, AkUInt32 uSize )

     {

         memcpy( pDest, pSrc, uSize );

     }

     /// Platform Independent Helper

     inline void AkMemMove(void* pDest, const void* pSrc, AkUInt32 uSize)

     {

         memmove( pDest, pSrc, uSize );

     }

     /// Platform Independent Helper

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

     {

         memset( pDest, iVal, uSize );

     }

     // Time functions

     // ------------------------------------------------------------------

     /// Platform Independent Helper

     inline void PerformanceCounter( AkInt64 * out_piLastTime )

     {

         *out_piLastTime = nn::os::GetSystemTick().GetInt64Value();

     }

     /// Platform Independent Helper

     inline void PerformanceFrequency( AkInt64 * out_piFreq )

     {

         *out_piFreq = nn::os::GetSystemTickFrequency();

     }

     /// Platform Independent Helper

     inline void UpdatePerformanceFrequency()

     {

         AkInt64 iFreq;

         PerformanceFrequency(&iFreq);

         AK::g_fFreqRatio = (AkReal32)((AkReal64)iFreq / 1000);

     }

     /// Platform Independent Helper

     /// Returns a time range in milliseconds, using the sound engine's updated count->milliseconds ratio.

     inline AkReal32 Elapsed( const AkInt64 & in_iNow, const AkInt64 & in_iStart )

     {

         return ( in_iNow - in_iStart ) / AK::g_fFreqRatio;

     }

     template<class destType, class srcType>

     inline size_t AkSimpleConvertString( destType* in_pdDest, const srcType* in_pSrc, size_t in_MaxSize, size_t destStrLen(const destType *),  size_t srcStrLen(const srcType *) )

     { 

         size_t i;

         size_t lenToCopy = srcStrLen(in_pSrc);

         lenToCopy = (lenToCopy > in_MaxSize-1) ? in_MaxSize-1 : lenToCopy;

         for(i = 0; i < lenToCopy; i++)

         {

             in_pdDest[i] = (destType) in_pSrc[i];

         }

         in_pdDest[lenToCopy] = (destType)0;

         return lenToCopy;

     }

     /// Get the length, in characters, of a NULL-terminated AkUtf16 string

     /// \return The length, in characters, of the specified string (excluding terminating NULL)

     inline size_t AkUtf16StrLen(const AkUtf16* in_pStr)

     {

         size_t len = 0;

         while (*in_pStr != 0)

         {

             in_pStr++;

             len++;

         }

         return len;

     }

     /// Get the length, in characters, of a NULL-terminated AkOSChar string

     /// \return The length, in characters, of the specified string (excluding terminating NULL)

     AkForceInline size_t OsStrLen(const AkOSChar* in_pszString)

     {

         return (strlen(in_pszString));

     }

     /// AkOSChar version of snprintf().

     #define AK_OSPRINTF snprintf

 #define CONVERT_UTF16_TO_CHAR(_astring_, _charstring_) \

         _charstring_ = (char*)AkAlloca( (1 + AKPLATFORM::AkUtf16StrLen((const AkUtf16*)_astring_)) * sizeof(char) ); \

         AK_UTF16_TO_CHAR( _charstring_, (const AkUtf16*)_astring_, AKPLATFORM::AkUtf16StrLen((const AkUtf16*)_astring_)+1 ) 

     #define AK_UTF16_TO_CHAR(   in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, strlen, AKPLATFORM::AkUtf16StrLen )

     #define AK_UTF8_TO_OSCHAR(  in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, strlen, strlen )

     #define AK_UTF16_TO_OSCHAR( in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, strlen, AKPLATFORM::AkUtf16StrLen )

     #define AK_UTF16_TO_WCHAR(  in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, wcslen, AKPLATFORM::AkUtf16StrLen )

     #define AK_CHAR_TO_UTF16(   in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, AKPLATFORM::AkUtf16StrLen, strlen )

     #define AK_OSCHAR_TO_UTF16( in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, AKPLATFORM::AkUtf16StrLen, strlen )

     #define AK_WCHAR_TO_UTF16(  in_pdDest, in_pSrc, in_MaxSize )    AKPLATFORM::AkSimpleConvertString( in_pdDest, in_pSrc, in_MaxSize, AKPLATFORM::AkUtf16StrLen, wcslen )

     // Use with AkOSChar.

     #define AK_PATH_SEPARATOR   ("/")

     inline int OsStrCmp(const AkOSChar* in_pszString1, const AkOSChar* in_pszString2)

     {

         return (strcmp(in_pszString1, in_pszString2));

     }

     /// Compare two NULL-terminated AkOSChar strings up to the specified count of characters.

     /// \return

     /// - < 0 if in_pszString1 < in_pszString2

     /// -    0 if the two strings are identical

     /// - > 0 if in_pszString1 > in_pszString2

     /// \remark The comparison is case-sensitive

     inline int OsStrNCmp(const AkOSChar* in_pszString1, const AkOSChar* in_pszString2, size_t in_MaxCountSize)

     {

         return (strncmp(in_pszString1, in_pszString2, in_MaxCountSize));

     }

     /// String conversion helper

     inline AkInt32 AkWideCharToChar(const wchar_t*  in_pszUnicodeString,

         AkUInt32    in_uiOutBufferSize,

         char*       io_pszAnsiString)

     {

         AKASSERT(io_pszAnsiString != NULL);

         mbstate_t state;

         memset(&state, '\0', sizeof(state));

         return wcsrtombs(io_pszAnsiString,      // destination

             &in_pszUnicodeString,   // source

             in_uiOutBufferSize,     // destination length

             &state);                // 

     }

     /// String conversion helper

     inline AkInt32 AkCharToWideChar(const char* in_pszAnsiString,

         AkUInt32        in_uiOutBufferSize,

         void*           io_pvUnicodeStringBuffer)

     {

         AKASSERT(io_pvUnicodeStringBuffer != NULL);

         mbstate_t state;

         memset(&state, '\0', sizeof(state));

         return mbsrtowcs((wchar_t*)io_pvUnicodeStringBuffer,    // destination

             &in_pszAnsiString,          // source

             in_uiOutBufferSize,         // destination length

             &state);                    // 

     }

     inline AkInt32 AkUtf8ToWideChar(const char* in_pszUtf8String,

         AkUInt32        in_uiOutBufferSize,

         void*           io_pvUnicodeStringBuffer)

     {

         return AkCharToWideChar(in_pszUtf8String, in_uiOutBufferSize, io_pvUnicodeStringBuffer);

     }

     /// Safe unicode string copy.

     inline void SafeStrCpy(wchar_t * in_pDest, const wchar_t* in_pSrc, size_t in_uDestMaxNumChars)

     {

         size_t iSizeCopy = AkMin(in_uDestMaxNumChars - 1, wcslen(in_pSrc) + 1);

         wcsncpy(in_pDest, in_pSrc, iSizeCopy);

         in_pDest[iSizeCopy] = '\0';

     }

     /// Safe ansi string copy.

     inline void SafeStrCpy(char * in_pDest, const char* in_pSrc, size_t in_uDestMaxNumChars)

     {

         size_t iSizeCopy = AkMin(in_uDestMaxNumChars - 1, strlen(in_pSrc) + 1);

         strncpy(in_pDest, in_pSrc, iSizeCopy);

         in_pDest[iSizeCopy] = '\0';

     }

     /// Safe unicode string concatenation.

     inline void SafeStrCat(wchar_t * in_pDest, const wchar_t* in_pSrc, size_t in_uDestMaxNumChars)

     {

         size_t iAvailableSize = (int)(in_uDestMaxNumChars - wcslen(in_pDest) - 1);

         wcsncat(in_pDest, in_pSrc, AkMin(iAvailableSize, (int)wcslen(in_pSrc)));

     }

     /// Safe ansi string concatenation.

     inline void SafeStrCat(char * in_pDest, const char* in_pSrc, size_t in_uDestMaxNumChars)

     {

         size_t iAvailableSize = (int)(in_uDestMaxNumChars - strlen(in_pDest) - 1);

         strncat(in_pDest, in_pSrc, AkMin(iAvailableSize, (int)strlen(in_pSrc)));

     }

     inline int SafeStrFormat(wchar_t * in_pDest, size_t in_uDestMaxNumChars, const wchar_t* in_pszFmt, ...)

     {

         va_list args;

         va_start(args, in_pszFmt);

         int r = vswprintf(in_pDest, in_uDestMaxNumChars, in_pszFmt, args);

         va_end(args);

         return r;

     }

     inline int SafeStrFormat(char * in_pDest, size_t in_uDestMaxNumChars, const char* in_pszFmt, ...)

     {

         va_list args;

         va_start(args, in_pszFmt);

         int r = vsnprintf(in_pDest, in_uDestMaxNumChars, in_pszFmt, args);

         va_end(args);

         return r;

     }

     /// Stack allocations.

     #define AkAlloca( _size_ ) __builtin_alloca( _size_ )

 #if __BIGGEST_ALIGNMENT__ < AK_SIMD_ALIGNMENT

 #define AkAllocaSIMD( _size_ ) __builtin_alloca_with_align( _size_, AK_SIMD_ALIGNMENT*8 )

 #endif

 #ifndef AK_OPTIMIZED

     /// Output a debug message on the console (Unicode string)

     inline void OutputDebugMsg(const wchar_t* in_pszMsg)

     {

         wprintf(L"%ls", in_pszMsg);

     }

     /// Output a debug message on the console (Ansi string)

     inline void OutputDebugMsg(const char* in_pszMsg)

     {

         printf("%s", in_pszMsg);

     }

     /// Output a debug message on the console (variadic function).

     template <int MaxSize = 0> // Unused

     inline void OutputDebugMsgV(const wchar_t* in_pszFmt, ...)

     {

         va_list args;

         va_start(args, in_pszFmt);

         vwprintf(in_pszFmt, args);

         va_end(args);

     }

     /// Output a debug message on the console (variadic function).

     template <int MaxSize = 0> // Unused

     inline void OutputDebugMsgV(const char* in_pszFmt, ...)

     {

         va_list args;

         va_start(args, in_pszFmt);

         vprintf(in_pszFmt, args);

         va_end(args);

     }

 #else

     inline void OutputDebugMsg(const wchar_t*){}

     inline void OutputDebugMsg(const char*){}

     template <int MaxSize = 0>

     inline void OutputDebugMsgV(const wchar_t*, ...) {}

     template <int MaxSize = 0>

     inline void OutputDebugMsgV(const char*, ...) {}

 #endif

     /// Detects whether the string represents an absolute path to a file

     inline bool IsAbsolutePath(const AkOSChar* in_pszPath, size_t in_pathLen)

     {

         // An absolute path is of the form: "MOUNTNAME:/..."

         return strstr(in_pszPath, ":/") != nullptr;

     }

     /// Converts a wchar_t string to an AkOSChar string.

     /// \remark On some platforms the AkOSChar string simply points to the same string,

     /// on others a new buffer is allocated on the stack using AkAlloca. This means

     /// you must make sure that:

     /// - The source string stays valid and unmodified for as long as you need the

     ///   AkOSChar string (for cases where they point to the same string)

     /// - The AkOSChar string is used within this scope only -- for example, do NOT

     ///   return that string from a function (for cases where it is allocated on the stack)

 #define CONVERT_WIDE_TO_OSCHAR( _wstring_, _oscharstring_ ) \

            _oscharstring_ = (AkOSChar*)AkAlloca( (1 + wcslen( _wstring_ )) * sizeof(AkOSChar) ); \

            AKPLATFORM::AkWideCharToChar( _wstring_ , (AkUInt32)(1 + wcslen( _wstring_ )), (AkOSChar*)( _oscharstring_ ) )

     /// Converts a char string to an AkOSChar string.

     /// \remark On some platforms the AkOSChar string simply points to the same string,

     /// on others a new buffer is allocated on the stack using AkAlloca. This means

     /// you must make sure that:

     /// - The source string stays valid and unmodified for as long as you need the

     ///   AkOSChar string (for cases where they point to the same string)

     /// - The AkOSChar string is used within this scope only -- for example, do NOT

     ///   return that string from a function (for cases where it is allocated on the stack)

 #define CONVERT_CHAR_TO_OSCHAR( _astring_, _oscharstring_ ) ( _oscharstring_ ) = (AkOSChar*)( _astring_ )

     /// Converts a AkOSChar string into wide char string.

     /// \remark On some platforms the AkOSChar string simply points to the same string,

     /// on others a new buffer is allocated on the stack using AkAlloca. This means

     /// you must make sure that:

     /// - The source string stays valid and unmodified for as long as you need the

     ///   AkOSChar string (for cases where they point to the same string)

     /// - The AkOSChar string is used within this scope only -- for example, do NOT

     ///   return that string from a function (for cases where it is allocated on the stack)

 #define CONVERT_OSCHAR_TO_WIDE( _osstring_, _wstring_ ) \

         _wstring_ = (wchar_t*)AkAlloca((1+strlen(_osstring_)) * sizeof(wchar_t)); \

         AKPLATFORM::AkCharToWideChar( _osstring_, (AkUInt32)(1 + strlen(_osstring_ )), _wstring_ )

     /// Converts a AkOSChar string into char string.

     /// \remark On some platforms the AkOSChar string simply points to the same string,

     /// on others a new buffer is allocated on the stack using AkAlloca. This means

     /// you must make sure that:

     /// - The source string stays valid and unmodified for as long as you need the

     ///   AkOSChar string (for cases where they point to the same string)

     /// - The AkOSChar string is used within this scope only -- for example, do NOT

     ///   return that string from a function (for cases where it is allocated on the stack)

 #define CONVERT_OSCHAR_TO_CHAR( _osstring_, _astring_ ) _astring_ = (char*)_osstring_

     #define AK_PATH_SEPARATOR   ("/")

     #define AK_LIBRARY_PREFIX   ("")

     #define AK_DYNAMIC_LIBRARY_EXTENSION    ("")

     #define AK_FILEHANDLE_TO_UINTPTR(_h) ((AkUIntPtr)_h.handle)

     #define AK_SET_FILEHANDLE_TO_UINTPTR(_h,_u) _h.handle = (void*)_u

 }

AkThread::pStackAlloc

AkUInt8 * pStackAlloc

Definition: AkTypes.h:94

AKPLATFORM::AkCreateSemaphore

AKRESULT AkCreateSemaphore(AkSemaphore &out_semaphore, AkUInt32 in_initialCount)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:99

AKPLATFORM::AkUtf16StrLen

size_t AkUtf16StrLen(const AkUtf16 *in_pStr)

Definition: AkPlatformFuncs.h:582

Audiokinetic namespace.

Definition: AkWwiseSDKVersion.cs:31

AkThreadProperties

Definition: AkPlatformFuncs.h:47

AkEvent

semaphore_t AkEvent

Definition: AkTypes.h:73

AKPLATFORM::FreeVM

AkForceInline void FreeVM(void *address, size_t size, size_t extra, size_t release)

Definition: AkPlatformFuncs.h:262

AkThreadProperties::nPriority

int nPriority

Thread priority.

Definition: AkPlatformFuncs.h:48

AKPLATFORM::AkClearEvent

void AkClearEvent(AkEvent &out_event)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:51

AKPLATFORM::AkClearSemaphore

AkForceInline void AkClearSemaphore(AkSemaphore &io_semaphore)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:93

AKPLATFORM

Platform-dependent helpers.

Definition: AkPlatformFuncs.h:156

AKPLATFORM::AkWaitForEvent

void AkWaitForEvent(AkEvent &in_event)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:79

AKPLATFORM::UpdatePerformanceFrequency

AkForceInline void UpdatePerformanceFrequency()

Platform Independent Helper.

Definition: AkPlatformFuncs.h:429

AkThreadID

int AkThreadID

Definition: AkTypes.h:69

AkThreadProperties::affinityMask

nn::Bit64 affinityMask

Affinity mask for each core: see nn::os::SetThreadCoreMask documentation.

Definition: AkPlatformFuncs.h:52

AKRESULT

Standard function call result.

Definition: AkTypes.h:193

AKPLATFORM::OutputDebugMsg

void OutputDebugMsg(const char *in_pszMsg)

Output a debug message on the console (Ansi string)

Definition: AkPlatformFuncs.h:120

AKPLATFORM::AllocVM

AkForceInline void * AllocVM(size_t size, size_t *extra)

Definition: AkPlatformFuncs.h:243

AK_THREAD_PRIORITY_NORMAL

#define AK_THREAD_PRIORITY_NORMAL

Definition: AkPlatformFuncs.h:72

AkOSChar

char AkOSChar

Generic character string.

Definition: AkTypes.h:60

AkUInt8

uint8_t AkUInt8

Unsigned 8-bit integer.

Definition: AkNumeralTypes.h:36

AKPLATFORM::SafeStrFormat

int SafeStrFormat(wchar_t *in_pDest, size_t in_uDestMaxNumChars, const wchar_t *in_pszFmt,...)

Definition: AkPlatformFuncs.h:512

NULL

#define NULL

Definition: AkTypes.h:46

AKPLATFORM::CurrentThread

AkThreadID CurrentThread()

Returns the calling thread's ID.

Definition: AkPlatformFuncs.h:380

AKPLATFORM::IsAbsolutePath

bool IsAbsolutePath(const AkOSChar *in_pszPath, size_t in_pathLen)

Detects whether the string represents an absolute path to a file.

Definition: AkPlatformFuncs.h:620

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:46

AK_Success

@ AK_Success

The operation was successful.

Definition: AkTypes.h:195

AkInt32

int32_t AkInt32

Signed 32-bit integer.

Definition: AkNumeralTypes.h:43

AkMin

#define AkMin(x1, x2)

Definition: AkPlatformFuncs.h:41

AKPLATFORM::AkCreateThread

void AkCreateThread(AkThreadRoutine pStartRoutine, void *pParams, const AkThreadProperties &in_threadProperties, AkThread *out_pThread, const char *)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:182

AkUtf16

AkUInt16 AkUtf16

Definition: AkTypes.h:61

AKPLATFORM::OutputDebugMsgV

void OutputDebugMsgV(const char *in_pszFmt,...)

Output a debug message on the console (variadic function).

Definition: AkPlatformFuncs.h:129

AKPLATFORM::PerformanceCounter

void PerformanceCounter(AkInt64 *out_piLastTime)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:142

AKPLATFORM::AkDestroySemaphore

void AkDestroySemaphore(AkSemaphore &io_semaphore)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:111

AKPLATFORM::AkDestroyEvent

void AkDestroyEvent(AkEvent &io_event)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:69

AkThreadRoutine

nn::os::ThreadFunction AkThreadRoutine

Thread routine.

Definition: AkTypes.h:85

AKPLATFORM::AkIsValidThread

AkForceInline bool AkIsValidThread(AkThread *in_pThread)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:277

AKPLATFORM::AkMemCpy

AkForceInline void AkMemCpy(void *pDest, const void *pSrc, AkUInt32 uSize)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:395

AKASSERT

#define AKASSERT(Condition)

Definition: AkAssert.h:67

AKPLATFORM::AkSleep

AkForceInline void AkSleep(AkUInt32 in_ulMilliseconds)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:386

AKPLATFORM::AkClearThread

AkForceInline void AkClearThread(AkThread *in_pThread)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:283

AKPLATFORM::AkGetDefaultThreadProperties

AkForceInline void AkGetDefaultThreadProperties(AkThreadProperties &out_threadProperties)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:302

AKPLATFORM::OsStrNCmp

int OsStrNCmp(const AkOSChar *in_pszString1, const AkOSChar *in_pszString2, size_t in_MaxCountSize)

Definition: AkPlatformFuncs.h:614

AkThread::sizExtra

size_t sizExtra

Definition: AkTypes.h:95

AKPLATFORM::AkMemSet

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

Platform Independent Helper.

Definition: AkPlatformFuncs.h:407

AKPLATFORM::AkMemMove

void AkMemMove(void *pDest, const void *pSrc, AkUInt32 uSize)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:401

AK::g_fFreqRatio

AkReal32 g_fFreqRatio

Definition: AkPlatformFuncs.h:63

AkReal64

double AkReal64

64-bit floating point

Definition: AkNumeralTypes.h:47

AKPLATFORM::AkCreateEvent

AKRESULT AkCreateEvent(AkEvent &out_event)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:57

AkThreadProperties::iIdealCore

int iIdealCore

Preferred core number: see nn::os::SetThreadCoreMask documentation.

Definition: AkPlatformFuncs.h:51

AKPLATFORM::SafeStrCpy

AkForceInline void SafeStrCpy(wchar_t *in_pDest, const wchar_t *in_pSrc, size_t in_uDestMaxNumChars)

Safe unicode string copy.

Definition: AkPlatformFuncs.h:483

AkInt64

int64_t AkInt64

Signed 64-bit integer.

Definition: AkNumeralTypes.h:44

AkThread::thread

nn::os::ThreadType thread

Definition: AkTypes.h:93

AKPLATFORM::AkWaitForSemaphore

void AkWaitForSemaphore(AkSemaphore &in_semaphore)

Platform Independent Helper - Semaphore wait, aka Operation P. Decrements value of semaphore,...

Definition: AkPlatformFuncs.h:117

AkThread::uStackSize

AkUInt32 uStackSize

Definition: AkTypes.h:96

AkTypes.h

AkThreadProperties::uStackSize

size_t uStackSize

Thread stack size.

Definition: AkPlatformFuncs.h:50

AKPLATFORM::PerformanceFrequency

void PerformanceFrequency(AkInt64 *out_piFreq)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:45

AKPLATFORM::AkCharToWideChar

AkForceInline AkInt32 AkCharToWideChar(const char *in_pszAnsiString, AkUInt32 in_uiOutBufferSize, void *io_pvUnicodeStringBuffer)

String conversion helper.

Definition: AkPlatformFuncs.h:460

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer.

Definition: AkNumeralTypes.h:38

AKPLATFORM::AkReleaseSemaphore

void AkReleaseSemaphore(AkSemaphore &in_semaphore, AkUInt32 in_count)

Platform Independent Helper - Semaphore signal, aka Operation V. Increments value of semaphore by an ...

Definition: AkPlatformFuncs.h:123

AKPLATFORM::SafeStrCat

AkForceInline void SafeStrCat(wchar_t *in_pDest, const wchar_t *in_pSrc, size_t in_uDestMaxNumChars)

Safe unicode string concatenation.

Definition: AkPlatformFuncs.h:499

AKPLATFORM::AkWideCharToChar

AkForceInline AkInt32 AkWideCharToChar(const wchar_t *in_pszUnicodeString, AkUInt32 in_uiOutBufferSize, char *io_pszAnsiString)

String conversion helper.

Definition: AkPlatformFuncs.h:443

AK_DEFAULT_STACK_SIZE

#define AK_DEFAULT_STACK_SIZE

Definition: AkPlatformFuncs.h:75

AKPLATFORM::AkWaitForSingleThread

AkForceInline void AkWaitForSingleThread(AkThread *in_pThread)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:373

AkAssert.h

AkThreadProperties::nPriority

AkInt32 nPriority

Thread priority. 0=highest, 31=lowest.

Definition: AkPlatformFuncs.h:49

AKPLATFORM::AkSignalEvent

void AkSignalEvent(const AkEvent &in_event)

Platform Independent Helper.

Definition: AkPlatformFuncs.h:86

AKPLATFORM::AkSimpleConvertString

size_t AkSimpleConvertString(destType *in_pdDest, const srcType *in_pSrc, size_t in_MaxSize, size_t destStrLen(const destType *), size_t srcStrLen(const srcType *))

Definition: AkPlatformFuncs.h:152

AkThread

Definition: AkTypes.h:90

AKPLATFORM::AkUtf8ToWideChar

AkForceInline AkInt32 AkUtf8ToWideChar(const char *in_pszUtf8String, AkUInt32 in_uiOutBufferSize, void *io_pvUnicodeStringBuffer)

String conversion helper.

Definition: AkPlatformFuncs.h:475

AkSemaphore

semaphore_t AkSemaphore

Definition: AkTypes.h:74

AKPLATFORM::AkCloseThread

AkForceInline void AkCloseThread(AkThread *in_pThread)