669 lines
18 KiB
C
669 lines
18 KiB
C
/*
|
||
//////////////////////////////////////////////////////////////
|
||
// SNDMEM.CXX - SOUNDxD Version 2.0
|
||
//////////////////////////////////////////////////////////////
|
||
// Memory managing functions.
|
||
/////////////////////////////////////////////////////////////
|
||
*/
|
||
|
||
#include "SND/snddef.h"
|
||
|
||
#include "MMG.h"
|
||
|
||
#include "SND/sndmem.h"
|
||
#include "SND/snderr.h"
|
||
|
||
#ifndef NO_ACP_MEMORY
|
||
#define __DeclareGlobalVariableMmgSnd_h__
|
||
#include "SNDext/mmgsnd.h"
|
||
#include "SNDext/errsnd.h"
|
||
#endif //NO_ACP_MEMORY
|
||
|
||
#include "sndthrd.h"
|
||
|
||
typedef struct tdstBlockInfoPriv_{
|
||
char * p_cBeginBlock;
|
||
char * p_cEndBlock;
|
||
char * p_cFirstFree;
|
||
char * p_cMaxMem;
|
||
}tdstBlockInfoPriv;
|
||
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
void SND_fn_vInitMemoryAccessManagement();
|
||
void SND_fn_vDesInitMemoryAccessManagement();
|
||
LPTOP_LEVEL_EXCEPTION_FILTER g_pfnPrevExceptionHandler;
|
||
#endif
|
||
|
||
void SND_fn_vCheckMemory()
|
||
{
|
||
#if defined(DEBUG) || !defined(NDEBUG)
|
||
unsigned char ucBlockId;
|
||
unsigned long ulNbMalloc;
|
||
unsigned long ulNbFree;
|
||
tdstBlockInfoPriv *p_stMyBlockInfo;
|
||
unitAlloc * p_uaPtr;
|
||
unitAlloc * p_uaFreePtr;
|
||
unitAlloc uaTotalAllocatedSize;
|
||
unitAlloc uaTotalFreeSize;
|
||
unitAlloc uaRemainSpace;
|
||
unitAlloc uaBlockSize;
|
||
unitAlloc uaMaxUsed;
|
||
struct tdstBlockInfoPriv_ * a_stMyBlockInfo=g_a_p_stMmgModuleBlocksInfo[g_ucSndModuleId];
|
||
unsigned char ucModuleMaxBlocksNb=E_ucSndMaxBlocksNb;
|
||
|
||
Mmg_MEnterCriticalSection();
|
||
|
||
//for (ucBlockId=0; ucBlockId<ucModuleMaxBlocksNb; ucBlockId++)
|
||
//due to misalignement between MMG and SND, only first block is etstable
|
||
{
|
||
ucBlockId=0;
|
||
p_stMyBlockInfo = a_stMyBlockInfo + ucBlockId;
|
||
|
||
p_uaPtr=(unitAlloc *)p_stMyBlockInfo->p_cBeginBlock;
|
||
p_uaFreePtr = (unitAlloc *)p_stMyBlockInfo->p_cFirstFree;
|
||
uaTotalAllocatedSize = 0;
|
||
uaTotalFreeSize = 0;
|
||
ulNbFree = 0;
|
||
ulNbMalloc =0;
|
||
while (p_uaPtr < (unitAlloc *)p_stMyBlockInfo->p_cEndBlock){// scan all malloc
|
||
if (p_uaFreePtr == p_uaPtr){// it's a free
|
||
if (((unitAlloc *) *(p_uaFreePtr+1)) != (unitAlloc *) 0){
|
||
// not the last free
|
||
p_uaFreePtr = (unitAlloc *) *(p_uaFreePtr+1); // go to the next free
|
||
ulNbFree++;
|
||
uaTotalFreeSize += *p_uaPtr;
|
||
}
|
||
}
|
||
else{// this is a malloc
|
||
uaTotalAllocatedSize += *p_uaPtr;
|
||
ulNbMalloc++;
|
||
}
|
||
if (*(p_uaPtr)==0)
|
||
{
|
||
DebugBreak();
|
||
}
|
||
p_uaPtr += *(p_uaPtr);
|
||
}//end of while
|
||
|
||
if ((p_uaPtr != (unitAlloc *)(p_stMyBlockInfo->p_cEndBlock + 1)) && (uaTotalAllocatedSize)){
|
||
snd_assert(FALSE);
|
||
}
|
||
else {
|
||
uaBlockSize = p_stMyBlockInfo->p_cEndBlock - p_stMyBlockInfo->p_cBeginBlock +1;
|
||
uaMaxUsed = p_stMyBlockInfo->p_cMaxMem - p_stMyBlockInfo->p_cBeginBlock +1;
|
||
if ( (unitAlloc *) (p_uaFreePtr) == (unitAlloc *) NULL){
|
||
//all the space is used !!
|
||
uaRemainSpace = 0;
|
||
}
|
||
else {
|
||
uaRemainSpace = ((*p_uaFreePtr)<<C_uwShiftAllocSize);
|
||
}
|
||
|
||
uaTotalAllocatedSize <<= C_uwShiftAllocSize;
|
||
uaTotalFreeSize <<= C_uwShiftAllocSize;
|
||
}
|
||
}// end of the for block
|
||
|
||
Mmg_MLeaveCriticalSection();
|
||
#endif
|
||
}// Mmg_fn_vPrintUsedStaticMemory
|
||
|
||
|
||
#ifdef DEBUG_SON
|
||
#define NB_MALLOC_HISTO 10000
|
||
typedef struct {
|
||
void* pvPtr;
|
||
unsigned long ulSize;
|
||
} tdstMallocDescriptor;
|
||
static tdstMallocDescriptor dbg_MallocHisto[NB_MALLOC_HISTO];
|
||
static unsigned long dbg_ulNbDynMalloc=0;
|
||
static unsigned long dbg_ulSizeDynMalloc=0;
|
||
static unsigned long dbg_ulIdMaxDynMalloc=0;
|
||
static unsigned long dbg_ulMaxSizeDynMalloc=0;
|
||
static unsigned long dbg_ulNbMaxBlocs=0;
|
||
|
||
void dbg_fnMalloc(void* ptr,unsigned long size)
|
||
{
|
||
int i=0;
|
||
tdstMallocDescriptor *decr=&dbg_MallocHisto[0];
|
||
|
||
while ((i<NB_MALLOC_HISTO) && (decr->pvPtr!=NULL)) {i++;decr++;};
|
||
if (i<NB_MALLOC_HISTO)
|
||
{
|
||
decr->pvPtr=ptr;decr->ulSize=size;
|
||
dbg_ulNbDynMalloc++;dbg_ulSizeDynMalloc+=size;
|
||
if (dbg_ulSizeDynMalloc>dbg_ulMaxSizeDynMalloc)
|
||
{
|
||
dbg_ulMaxSizeDynMalloc=dbg_ulSizeDynMalloc;
|
||
dbg_ulIdMaxDynMalloc=dbg_ulNbDynMalloc;
|
||
dbg_ulNbMaxBlocs=0;decr=&dbg_MallocHisto[0];i=0;
|
||
while (i<NB_MALLOC_HISTO)
|
||
{
|
||
decr++;i++;
|
||
if (decr->pvPtr!=NULL) dbg_ulNbMaxBlocs++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void dbg_fnReAlloc(void* oldptr,void* newptr,unsigned long size)
|
||
{
|
||
int i=0;
|
||
tdstMallocDescriptor *decr=&dbg_MallocHisto[0];
|
||
|
||
while ((i<NB_MALLOC_HISTO) && (decr->pvPtr!=oldptr)) {i++;decr++;};
|
||
if (i<NB_MALLOC_HISTO)
|
||
{
|
||
dbg_ulSizeDynMalloc-=decr->ulSize;dbg_ulSizeDynMalloc+=size;
|
||
decr->pvPtr=newptr;decr->ulSize=size;
|
||
if (dbg_ulSizeDynMalloc>dbg_ulMaxSizeDynMalloc)
|
||
{
|
||
dbg_ulMaxSizeDynMalloc=dbg_ulSizeDynMalloc;
|
||
dbg_ulNbMaxBlocs=0;decr=&dbg_MallocHisto[0];i=0;
|
||
while (i<NB_MALLOC_HISTO)
|
||
{
|
||
decr++;i++;
|
||
if (decr->pvPtr!=NULL) dbg_ulNbMaxBlocs++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void dbg_fnFree(void* ptr)
|
||
{
|
||
int i=0;
|
||
tdstMallocDescriptor *decr=&dbg_MallocHisto[0];
|
||
|
||
while ((i<NB_MALLOC_HISTO) && (decr->pvPtr!=ptr)) {i++;decr++;}
|
||
if (i<NB_MALLOC_HISTO)
|
||
{
|
||
dbg_ulSizeDynMalloc-=decr->ulSize;dbg_ulNbDynMalloc--;
|
||
decr->pvPtr=NULL;decr->ulSize=0;
|
||
}
|
||
}
|
||
|
||
void dbg_fnReportDynMemory()
|
||
{
|
||
FILE* hFile;
|
||
SYSTEMTIME time;
|
||
|
||
if ((hFile=fopen("sndmemrp.txt","aw"))!=NULL)
|
||
{
|
||
GetLocalTime(&time);
|
||
fprintf(hFile,"--- Dynamic Memory used by SND ------------\xd\xa saved the %dth of %d, %d; at %2d:%2d:%2d\xd\xa",time.wMonth,time.wDay,time.wYear,time.wHour,time.wMinute,time.wSecond);
|
||
fprintf(hFile,"Maximum of %d bytes segmented in %d blocks\xd\xa\xd\xa",dbg_ulMaxSizeDynMalloc,dbg_ulNbMaxBlocs);
|
||
fclose(hFile);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifndef NO_ACP_MEMORY
|
||
#define C_SND_MAINBLOCK_SIZE 100*1024
|
||
#define C_SND_MAPBLOCK_SIZE 10*1024
|
||
|
||
//----------------------------------------------------------
|
||
// InitMallocSnd:init de la librairie MallocSnd
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vInitMallocSnd(void)
|
||
{
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
SND_fn_vInitMemoryAccessManagement();
|
||
#endif
|
||
|
||
Mmg_M_InitMmg(Snd);
|
||
|
||
Mmg_M_InitBlock(Snd,E_ucSndBlockMain,C_SND_MAINBLOCK_SIZE);
|
||
Mmg_M_InitBlock(Snd,E_ucSndBlockMap,C_SND_MAPBLOCK_SIZE);
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError (Snd,(unsigned long)GetCurrentThreadId()))
|
||
{
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
Erm_M_UpdateLastError(Snd,(unsigned long)GetCurrentThreadId(),E_uwSndMemoryBlockError, C_lErmNoDebugData,C_ucErmOpenInfoWindow, C_ucAllowStopForDebug,"");
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// InitMallocSnd:init de la librairie MallocSnd
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vDesInitMallocSnd(void)
|
||
{
|
||
#ifdef DEBUG_SON
|
||
dbg_fnReportDynMemory();
|
||
#endif
|
||
|
||
Mmg_M_FreeBlock(Snd,E_ucSndBlockMain);
|
||
Mmg_M_FreeBlock(Snd,E_ucSndBlockMap);
|
||
Mmg_M_DeleteBlock(Snd,E_ucSndBlockMain);
|
||
Mmg_M_DeleteBlock(Snd,E_ucSndBlockMap);
|
||
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
SND_fn_vDesInitMemoryAccessManagement();
|
||
#endif//MEMORY_ACCES_MANAGEMENT_MODE
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// MallocSnd:allocation d'un bloc m<>moire
|
||
// Entr<74>e:ulNbByte=nb d'octets <20> r<>server
|
||
// Sortie:pointeur sue le 1<> octet reserv<72>
|
||
//----------------------------------------------------------
|
||
void* SND_CALL SND_fn_pvMallocSnd(unsigned long ulNbBytes)
|
||
{
|
||
void* ptr_temp;
|
||
unsigned char ucChannel;
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,E_ucDynamic,ucChannel );
|
||
|
||
ptr_temp=Mmg_fn_p_vAlloc4Ch(ulNbBytes,ucChannel );
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg,(unsigned long)GetCurrentThreadId()))
|
||
{
|
||
SND_PrintUsedStaticMemory();
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
ptr_temp=NULL;
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
#ifdef DEBUG_SON
|
||
dbg_fnMalloc(ptr_temp,ulNbBytes);
|
||
#endif
|
||
|
||
return ptr_temp;
|
||
}
|
||
|
||
void* SND_CALL SND_fn_pvMallocSndEx(unsigned char id_block,unsigned long ulNbBytes)
|
||
{
|
||
void* ptr_temp;
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
ptr_temp=VirtualAlloc(NULL,ulNbBytes,MEM_COMMIT,PAGE_READWRITE);
|
||
|
||
if (id_block & MEMORY_ACCES_MANAGEMENT_FLAG)
|
||
{
|
||
|
||
}
|
||
#else
|
||
unsigned char ucChannel;
|
||
|
||
SND_fn_vCheckMemory();
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,id_block,ucChannel );
|
||
|
||
ptr_temp=Mmg_fn_p_vAlloc4Ch(ulNbBytes,ucChannel );
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg,(unsigned long)GetCurrentThreadId()))
|
||
{
|
||
SND_PrintUsedStaticMemory();
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
ptr_temp=NULL;
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
SND_fn_vCheckMemory();
|
||
#endif //MEMORY_ACCES_MANAGEMENT_MODE
|
||
|
||
return ptr_temp;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------
|
||
// ReAllocSnd:r<>-allocation d'un bloc m<>moire
|
||
// Entr<74>e:pvPtr=pointeur sur le 1<> octet de la zone <20> r<>allouer
|
||
// ulNbByte=nouveau nb d'octets <20> r<>server
|
||
// Sortie:pointeur sue le 1<> octet reserv<72>
|
||
//----------------------------------------------------------
|
||
void* SND_CALL SND_fn_pvReAllocSnd(void* pvPtr,unsigned long ulNbBytes)
|
||
{
|
||
void * p_vPtr;
|
||
unsigned char ucChannel;
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,E_ucDynamic,ucChannel);
|
||
|
||
p_vPtr = Mmg_fn_p_vRealloc4Ch(pvPtr,ulNbBytes,ucChannel);
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg,(unsigned long)GetCurrentThreadId()))
|
||
{
|
||
SND_PrintUsedStaticMemory();
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
#ifdef DEBUG_SON
|
||
dbg_fnReAlloc(pvPtr,p_vPtr,ulNbBytes);
|
||
#endif
|
||
|
||
return p_vPtr;
|
||
}
|
||
|
||
void* SND_CALL SND_fn_pvReAllocSndEx(unsigned char id_block,void* pvPtr,unsigned long ulNbBytes)
|
||
{
|
||
void * newPtr;
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD ret,prev_size,prev_protect;
|
||
|
||
newPtr=VirtualAlloc(0,ulNbBytes,MEM_COMMIT,PAGE_READWRITE);
|
||
if (!newPtr)
|
||
ret=GetLastError();
|
||
else
|
||
{
|
||
VirtualQuery(pvPtr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
prev_size=mem_info.RegionSize;
|
||
if (!(mem_info.Protect & PAGE_READWRITE))
|
||
VirtualProtect(pvPtr,prev_size,PAGE_READWRITE,&prev_protect);
|
||
CopyMemory(newPtr,pvPtr,min(ulNbBytes,prev_size));
|
||
if (!VirtualFree(pvPtr,0,MEM_RELEASE))
|
||
ret=GetLastError();
|
||
}
|
||
|
||
if (id_block & MEMORY_ACCES_MANAGEMENT_FLAG)
|
||
VirtualProtect(newPtr,ulNbBytes,PAGE_READONLY,&prev_protect);
|
||
|
||
snd_assert(newPtr);
|
||
#else
|
||
unsigned char ucChannel;
|
||
|
||
SND_fn_vCheckMemory();
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,id_block,ucChannel);
|
||
|
||
newPtr = Mmg_fn_p_vRealloc4Ch(pvPtr,ulNbBytes,ucChannel );
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg,(unsigned long)GetCurrentThreadId()))
|
||
{
|
||
SND_PrintUsedStaticMemory();
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
SND_fn_vCheckMemory();
|
||
#endif //MEMORY_ACCES_MANAGEMENT_MODE
|
||
|
||
return newPtr;
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// FreeSnd:lib<69>ration d'un bloc m<>moire
|
||
// Entr<74>e:pvPtr=pointeur sur le 1<> octet de la zone <20> lib<69>rer
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vFreeSnd(void* pvPtr)
|
||
{
|
||
unsigned char ucChannel;
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,E_ucDynamic,ucChannel);
|
||
|
||
Mmg_fn_vTestMallocIntegrityAt (pvPtr);
|
||
|
||
Mmg_fn_vFree4Ch(pvPtr,ucChannel);
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg, (unsigned long)GetCurrentThreadId()))
|
||
{
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
#ifdef DEBUG_SON
|
||
dbg_fnFree(pvPtr);
|
||
#endif
|
||
}
|
||
|
||
void SND_CALL SND_fn_vFreeSndEx(unsigned char id_block,void* pvPtr)
|
||
{
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
VirtualFree(pvPtr,0,MEM_RELEASE);
|
||
#else
|
||
unsigned char ucChannel;
|
||
long toto=(long)GetCurrentThreadId();
|
||
|
||
SND_fn_vCheckMemory();
|
||
|
||
ucChannel=Mmg_fn_ucGiveChannelId((unsigned long)GetCurrentThreadId(),0);
|
||
|
||
Mmg_M_SetModeAlloc4Ch(Snd,id_block,ucChannel );
|
||
|
||
Mmg_fn_vTestMallocIntegrityAt (pvPtr);
|
||
|
||
Mmg_fn_vFree4Ch(pvPtr,ucChannel);
|
||
|
||
SND_fn_vEnterCriticalSectionForErrorDisplay();
|
||
|
||
if (Erm_M_uwCheckError(Mmg, (unsigned long)GetCurrentThreadId()))
|
||
{
|
||
Erm_M_ClearLastError((unsigned long)GetCurrentThreadId());
|
||
SND_fn_vDisplayError(E_uwSndMemoryAllocError,"");
|
||
}
|
||
|
||
SND_fn_vQuitCriticalSectionForErrorDisplay();
|
||
|
||
Mmg_fn_vReleaseChannelId(ucChannel);
|
||
|
||
SND_fn_vCheckMemory();
|
||
#endif //MEMORY_ACCES_MANAGEMENT_MODE
|
||
}
|
||
|
||
void SND_CALL SND_fn_vResizeMemoryBlockSnd(unsigned char id,unsigned long size)
|
||
{
|
||
Mmg_M_InitBlock(Snd,id,size);
|
||
}
|
||
|
||
void SND_PrintUsedStaticMemory(void)
|
||
{
|
||
Mmg_M_PrintUsedStaticMemoryInModule(Snd);
|
||
}
|
||
|
||
#ifdef MEMORY_ACCES_MANAGEMENT_MODE
|
||
//Exception filter for SND acces viloation management
|
||
LONG WINAPI SND_fn_lUnhandledExceptionFilter(struct _EXCEPTION_POINTERS *ExceptionInfo)
|
||
{
|
||
char texte[128];
|
||
|
||
if (ExceptionInfo->ExceptionRecord->ExceptionCode==EXCEPTION_ACCESS_VIOLATION)
|
||
{
|
||
sprintf(texte,"Tentative d'<27>crasement m<>moire en %x",ExceptionInfo->ExceptionRecord->ExceptionInformation[1]);
|
||
if (MessageBox(NULL,"Do you want to (attempt to) modify bloc attributs ?",texte,MB_YESNO)==IDYES)
|
||
SND_fn_vLockMemoryWriteSnd_((void*)ExceptionInfo->ExceptionRecord->ExceptionInformation[1]);
|
||
}
|
||
else
|
||
MessageBox(NULL,"<EFBFBD>a va mal","ou<EFBFBD>lle",MB_OK);
|
||
|
||
return EXCEPTION_CONTINUE_SEARCH;
|
||
}
|
||
|
||
void SND_fn_vInitMemoryAccessManagement()
|
||
{
|
||
g_pfnPrevExceptionHandler=SetUnhandledExceptionFilter(SND_fn_lUnhandledExceptionFilter);
|
||
}
|
||
|
||
void SND_fn_vDesInitMemoryAccessManagement()
|
||
{
|
||
SetUnhandledExceptionFilter(g_pfnPrevExceptionHandler);
|
||
}
|
||
|
||
void SND_CALL SND_fn_vLockMemoryWriteSnd_(void* ptr)
|
||
{
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD prev_protect;
|
||
|
||
VirtualQuery(ptr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
snd_assert(mem_info.RegionSize);
|
||
snd_assert(mem_info.Protect==PAGE_READONLY);
|
||
|
||
VirtualProtect(ptr,mem_info.RegionSize,PAGE_READWRITE,&prev_protect);
|
||
}
|
||
|
||
void SND_CALL SND_fn_vLockMemoryReadSnd_(void* ptr)
|
||
{
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD prev_protect;
|
||
|
||
VirtualQuery(ptr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
snd_assert(mem_info.RegionSize);
|
||
snd_assert(mem_info.Protect==PAGE_READONLY);
|
||
|
||
VirtualProtect(ptr,mem_info.RegionSize,PAGE_READONLY,&prev_protect);
|
||
}
|
||
|
||
void SND_CALL SND_fn_vUnLockMemoryWriteSnd_(void* ptr)
|
||
{
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD prev_protect;
|
||
|
||
VirtualQuery(ptr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
snd_assert(mem_info.RegionSize);
|
||
snd_assert(mem_info.Protect==PAGE_READWRITE);
|
||
|
||
VirtualProtect(ptr,mem_info.RegionSize,PAGE_READONLY,&prev_protect);
|
||
}
|
||
|
||
void SND_CALL SND_fn_vUnLockMemoryReadSnd_(void* ptr)
|
||
{
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD prev_protect;
|
||
|
||
VirtualQuery(ptr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
snd_assert(mem_info.RegionSize);
|
||
snd_assert(mem_info.Protect==PAGE_READONLY);
|
||
|
||
VirtualProtect(ptr,mem_info.RegionSize,PAGE_READONLY,&prev_protect);
|
||
}
|
||
#endif //MEMORY_ACCES_MANAGEMENT_MODE
|
||
|
||
#else //NO_ACP_MEMORY
|
||
//----------------------------------------------------------
|
||
// InitMallocSnd:init de la librairie MallocSnd
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vInitMallocSnd(void)
|
||
{
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// InitMallocSnd:init de la librairie MallocSnd
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vDesInitMallocSnd(void)
|
||
{
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// MallocSnd:allocation d'un bloc m<>moire
|
||
// Entr<74>e:ulNbByte=nb d'octets <20> r<>server
|
||
// Sortie:pointeur sue le 1<> octet reserv<72>
|
||
//----------------------------------------------------------
|
||
void* SND_CALL SND_fn_pvMallocSnd(unsigned long ulNbBytes)
|
||
{
|
||
return VirtualAlloc(0,ulNbBytes,MEM_COMMIT,PAGE_READWRITE);
|
||
}
|
||
|
||
void* SND_CALL SND_fn_pvMallocSndEx(unsigned char id,unsigned long ulNbBytes)
|
||
{
|
||
return SND_fn_pvMallocSnd(ulNbBytes);
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// ReAllocSnd:r<>-allocation d'un bloc m<>moire
|
||
// Entr<74>e:pvPtr=pointeur sur le 1<> octet de la zone <20> r<>allouer
|
||
// ulNbByte=nouveau nb d'octets <20> r<>server
|
||
// Sortie:pointeur sue le 1<> octet reserv<72>
|
||
//----------------------------------------------------------
|
||
void* SND_CALL SND_fn_pvReAllocSnd(void* pvPtr,unsigned long ulNbBytes)
|
||
{
|
||
void *new_pvPtr;
|
||
DWORD ret;
|
||
MEMORY_BASIC_INFORMATION mem_info;
|
||
DWORD prev_size;
|
||
|
||
if (pvPtr != NULL)
|
||
{
|
||
new_pvPtr=VirtualAlloc(0,ulNbBytes,MEM_COMMIT,PAGE_READWRITE);
|
||
if (!new_pvPtr)
|
||
ret=GetLastError();
|
||
else
|
||
{
|
||
VirtualQuery(pvPtr,&mem_info,sizeof(MEMORY_BASIC_INFORMATION));
|
||
prev_size=mem_info.RegionSize;
|
||
CopyMemory(new_pvPtr,pvPtr,min(ulNbBytes,prev_size));
|
||
if (!VirtualFree(pvPtr,0,MEM_RELEASE))
|
||
ret=GetLastError();
|
||
}
|
||
}
|
||
else
|
||
new_pvPtr=NULL;
|
||
|
||
return new_pvPtr;
|
||
}
|
||
|
||
void* SND_CALL SND_fn_pvReAllocSndEx(unsigned char id,void* pvPtr,unsigned long ulNbBytes)
|
||
{
|
||
return SND_fn_pvReAllocSnd(pvPtr,ulNbBytes);
|
||
}
|
||
|
||
//----------------------------------------------------------
|
||
// FreeSnd:lib<69>ration d'un bloc m<>moire
|
||
// Entr<74>e:pvPtr=pointeur sur le 1<> octet de la zone <20> lib<69>rer
|
||
//----------------------------------------------------------
|
||
void SND_CALL SND_fn_vFreeSnd(void* pvPtr)
|
||
{
|
||
DWORD ret;
|
||
|
||
if (pvPtr != NULL)
|
||
if (!VirtualFree(pvPtr,0,MEM_RELEASE))
|
||
ret=GetLastError();
|
||
}
|
||
|
||
void SND_CALL SND_fn_vFreeSndEx(unsigned char id,void* pvPtr)
|
||
{
|
||
SND_fn_vFreeSnd(pvPtr);
|
||
}
|
||
|
||
void SND_CALL SND_fn_vResizestaticBlockSnd(int id,long size)
|
||
{
|
||
}
|
||
|
||
void SND_PrintUsedStaticMemory (void)
|
||
{
|
||
}
|
||
|
||
#endif //NO_ACP_MEMORY
|
||
|