[Scummvm-cvs-logs] SF.net SVN: scummvm:[45401] scummvm/trunk/engines/tinsel
fingolfin at users.sourceforge.net
fingolfin at users.sourceforge.net
Mon Oct 26 11:41:11 CET 2009
Revision: 45401
http://scummvm.svn.sourceforge.net/scummvm/?rev=45401&view=rev
Author: fingolfin
Date: 2009-10-26 10:41:11 +0000 (Mon, 26 Oct 2009)
Log Message:
-----------
TINSEL: Remove DWM_FIXED and add new MemoryAllocFixed() function
Modified Paths:
--------------
scummvm/trunk/engines/tinsel/dialogs.cpp
scummvm/trunk/engines/tinsel/handle.cpp
scummvm/trunk/engines/tinsel/heapmem.cpp
scummvm/trunk/engines/tinsel/heapmem.h
Modified: scummvm/trunk/engines/tinsel/dialogs.cpp
===================================================================
--- scummvm/trunk/engines/tinsel/dialogs.cpp 2009-10-26 10:40:51 UTC (rev 45400)
+++ scummvm/trunk/engines/tinsel/dialogs.cpp 2009-10-26 10:41:11 UTC (rev 45401)
@@ -5526,7 +5526,7 @@
if (TinselV0) {
// In Tinsel 0, the INV_OBJECT structure doesn't have an attributes field, so we
// need to 'unpack' the source structures into the standard Tinsel v1/v2 format
- invObjects = (INV_OBJECT *)MemoryAlloc(DWM_FIXED, numObjects * sizeof(INV_OBJECT));
+ invObjects = (INV_OBJECT *)MemoryAllocFixed(numObjects * sizeof(INV_OBJECT));
byte *srcP = (byte *)cptr;
INV_OBJECT *destP = (INV_OBJECT *)invObjects;
@@ -5535,9 +5535,11 @@
destP->attribute = 0;
}
} else if (TinselV2) {
- if (invFilms == NULL)
+ if (invFilms == NULL) {
// First time - allocate memory
- invFilms = (SCNHANDLE *)MemoryAlloc(DWM_FIXED | DWM_ZEROINIT, numObjects * sizeof(SCNHANDLE));
+ invFilms = (SCNHANDLE *)MemoryAllocFixed(numObjects * sizeof(SCNHANDLE));
+ memset(invFilms, 0, numObjects * sizeof(SCNHANDLE));
+ }
if (invFilms == NULL)
error(NO_MEM, "inventory scripts");
Modified: scummvm/trunk/engines/tinsel/handle.cpp
===================================================================
--- scummvm/trunk/engines/tinsel/handle.cpp 2009-10-26 10:40:51 UTC (rev 45400)
+++ scummvm/trunk/engines/tinsel/handle.cpp 2009-10-26 10:41:11 UTC (rev 45401)
@@ -48,9 +48,10 @@
//----------------- LOCAL DEFINES --------------------
struct MEMHANDLE {
- char szName[12]; ///< 00 - file name of graphics file
- int32 filesize; ///< 12 - file size and flags
- MEM_NODE *pNode; ///< 16 - memory node for the graphics
+ char szName[12]; ///< file name of graphics file
+ int32 filesize; ///< file size and flags
+ MEM_NODE *_node; ///< memory node for the graphics
+ uint8 *_ptr; ///< start of data for fixed blocks (i.e., preloaded data)
uint32 flags2;
};
@@ -127,7 +128,8 @@
handleTable[i].filesize = f.readUint32LE();
// The pointer should always be NULL. We don't
// need to read that from the file.
- handleTable[i].pNode = NULL;
+ handleTable[i]._node = NULL;
+ handleTable[i]._ptr = NULL;
f.seek(4, SEEK_CUR);
// For Discworld 2, read in the flags2 field
handleTable[i].flags2 = t2Flag ? f.readUint32LE() : 0;
@@ -151,30 +153,30 @@
for (i = 0, pH = handleTable; i < numHandles; i++, pH++) {
if (pH->filesize & fPreload) {
// allocate a fixed memory node for permanent files
- pH->pNode = MemoryAlloc(DWM_FIXED, sizeof(MEM_NODE) + (pH->filesize & FSIZE_MASK));
+ pH->_ptr = (uint8 *)MemoryAllocFixed((pH->filesize & FSIZE_MASK));
+ pH->_node = NULL;
// make sure memory allocated
- assert(pH->pNode);
+ assert(pH->_ptr);
- // Initialise the MEM_NODE structure
- memset(pH->pNode, 0, sizeof(MEM_NODE));
-
// load the data
LoadFile(pH, true);
}
#ifdef BODGE
else if ((pH->filesize & FSIZE_MASK) == 8) {
- pH->pNode = NULL;
+ pH->_node = NULL;
+ pH->_ptr = NULL;
}
#endif
else {
// allocate a discarded memory node for other files
- pH->pNode = MemoryAlloc(
+ pH->_node = MemoryAlloc(
DWM_MOVEABLE | DWM_DISCARDABLE | DWM_NOALLOC,
pH->filesize & FSIZE_MASK);
+ pH->_ptr = NULL;
// make sure memory allocated
- assert(pH->pNode);
+ assert(pH->_node || pH->_ptr);
}
}
}
@@ -213,7 +215,7 @@
assert(!(pH->filesize & fPreload));
// discardable - lock the memory
- addr = (byte *)MemoryLock(pH->pNode);
+ addr = (byte *)MemoryLock(pH->_node);
// make sure address is valid
assert(addr);
@@ -230,7 +232,7 @@
}
// discardable - unlock the memory
- MemoryUnlock(pH->pNode);
+ MemoryUnlock(pH->_node);
// set the loaded flag
pH->filesize |= fLoaded;
@@ -256,8 +258,8 @@
OpenCDGraphFile();
- if ((handleTable + cdPlayHandle)->pNode->pBaseAddr != NULL)
- MemoryDiscard((handleTable + cdPlayHandle)->pNode); // Free it
+ if ((handleTable + cdPlayHandle)->_node->pBaseAddr != NULL)
+ MemoryDiscard((handleTable + cdPlayHandle)->_node); // Free it
// It must always be the same
assert(cdPlayHandle == (start >> SCNHANDLE_SHIFT));
@@ -301,19 +303,19 @@
if (pH->filesize & fPreload)
// preload - no need to lock the memory
- addr = (uint8 *)pH->pNode + sizeof(MEM_NODE);
+ addr = pH->_ptr;
else {
// discardable - lock the memory
- addr = (uint8 *)MemoryLock(pH->pNode);
+ addr = (uint8 *)MemoryLock(pH->_node);
}
#ifdef DEBUG
if (addr == NULL) {
if (pH->filesize & fPreload)
// preload - no need to lock the memory
- addr = (uint8 *)pH->pNode;
+ addr = pH->_ptr;
else {
// discardable - lock the memory
- addr = (uint8 *)MemoryLock(pH->pNode);
+ addr = (uint8 *)MemoryLock(pH->_node);
}
}
#endif
@@ -328,7 +330,7 @@
if ((pH->filesize & fPreload) == 0) {
// discardable - unlock the memory
- MemoryUnlock(pH->pNode);
+ MemoryUnlock(pH->_node);
}
// set the loaded flag
@@ -362,50 +364,52 @@
pH = handleTable + handle;
if (pH->filesize & fPreload) {
+#if 0
if (TinselV2)
// update the LRU time (new in this file)
pH->pNode->lruTime = DwGetCurrentTime();
+#endif
// permanent files are already loaded
- return (uint8 *)pH->pNode + sizeof(MEM_NODE) + (offset & OFFSETMASK);
+ return pH->_ptr + (offset & OFFSETMASK);
} else if (handle == cdPlayHandle) {
// Must be in currently loaded/loadable range
if (offset < cdBaseHandle || offset >= cdTopHandle)
error("Overlapping (in time) CD-plays");
- if (pH->pNode->pBaseAddr && (pH->filesize & fLoaded))
+ if (pH->_node->pBaseAddr && (pH->filesize & fLoaded))
// already allocated and loaded
- return pH->pNode->pBaseAddr + ((offset - cdBaseHandle) & OFFSETMASK);
+ return pH->_node->pBaseAddr + ((offset - cdBaseHandle) & OFFSETMASK);
- if (pH->pNode->pBaseAddr == NULL)
+ if (pH->_node->pBaseAddr == NULL)
// must have been discarded - reallocate the memory
- MemoryReAlloc(pH->pNode, cdTopHandle-cdBaseHandle,
+ MemoryReAlloc(pH->_node, cdTopHandle-cdBaseHandle,
DWM_MOVEABLE | DWM_DISCARDABLE);
- if (pH->pNode->pBaseAddr == NULL)
+ if (pH->_node->pBaseAddr == NULL)
error("Out of memory");
LoadCDGraphData(pH);
// make sure address is valid
- assert(pH->pNode->pBaseAddr);
+ assert(pH->_node->pBaseAddr);
// update the LRU time (new in this file)
- pH->pNode->lruTime = DwGetCurrentTime();
+ pH->_node->lruTime = DwGetCurrentTime();
- return pH->pNode->pBaseAddr + ((offset - cdBaseHandle) & OFFSETMASK);
+ return pH->_node->pBaseAddr + ((offset - cdBaseHandle) & OFFSETMASK);
} else {
- if (pH->pNode->pBaseAddr && (pH->filesize & fLoaded))
+ if (pH->_node->pBaseAddr && (pH->filesize & fLoaded))
// already allocated and loaded
- return pH->pNode->pBaseAddr + (offset & OFFSETMASK);
+ return pH->_node->pBaseAddr + (offset & OFFSETMASK);
- if (pH->pNode->pBaseAddr == NULL)
+ if (pH->_node->pBaseAddr == NULL)
// must have been discarded - reallocate the memory
- MemoryReAlloc(pH->pNode, pH->filesize & FSIZE_MASK,
+ MemoryReAlloc(pH->_node, pH->filesize & FSIZE_MASK,
DWM_MOVEABLE | DWM_DISCARDABLE);
- if (pH->pNode->pBaseAddr == NULL)
+ if (pH->_node->pBaseAddr == NULL)
error("Out of memory");
if (TinselV2) {
@@ -415,9 +419,9 @@
LoadFile(pH, true);
// make sure address is valid
- assert(pH->pNode->pBaseAddr);
+ assert(pH->_node->pBaseAddr);
- return pH->pNode->pBaseAddr + (offset & OFFSETMASK);
+ return pH->_node->pBaseAddr + (offset & OFFSETMASK);
}
}
@@ -447,7 +451,7 @@
// WORKAROUND: The original didn't include the DWM_LOCKED flag. It's being
// included because the method is 'LockScene' so it's presumed that the
// point of this was that the scene's memory block be locked
- MemoryReAlloc(pH->pNode, pH->filesize & FSIZE_MASK, DWM_MOVEABLE | DWM_LOCKED);
+ MemoryReAlloc(pH->_node, pH->filesize & FSIZE_MASK, DWM_MOVEABLE | DWM_LOCKED);
#ifdef DEBUG
bLockedScene = true;
#endif
@@ -470,7 +474,7 @@
if ((pH->filesize & fPreload) == 0) {
// change the flags for the node
- MemoryReAlloc(pH->pNode, pH->filesize & FSIZE_MASK, DWM_MOVEABLE | DWM_DISCARDABLE);
+ MemoryReAlloc(pH->_node, pH->filesize & FSIZE_MASK, DWM_MOVEABLE | DWM_DISCARDABLE);
#ifdef DEBUG
bLockedScene = false;
#endif
@@ -510,7 +514,8 @@
pH = handleTable + handle;
// update the LRU time whether its loaded or not!
- pH->pNode->lruTime = DwGetCurrentTime();
+ if (pH->_node)
+ pH->_node->lruTime = DwGetCurrentTime();
}
}
Modified: scummvm/trunk/engines/tinsel/heapmem.cpp
===================================================================
--- scummvm/trunk/engines/tinsel/heapmem.cpp 2009-10-26 10:40:51 UTC (rev 45400)
+++ scummvm/trunk/engines/tinsel/heapmem.cpp 2009-10-26 10:41:11 UTC (rev 45401)
@@ -279,11 +279,6 @@
MEM_NODE *pNode;
bool bCompacted = true; // set when heap has been compacted
- // compact the heap if we are allocating fixed memory
- if (flags & DWM_FIXED) {
- HeapCompact(MAX_INT, false);
- }
-
#ifdef SCUMM_NEED_ALIGNMENT
const int alignPadding = sizeof(void*) - 1;
size = (size + alignPadding) & ~alignPadding; //round up to nearest multiple of sizeof(void*), this ensures the addresses that are returned are alignment-safe.
@@ -307,12 +302,8 @@
if (flags & DWM_ZEROINIT)
memset(pNode->pBaseAddr, 0, size);
- if (flags & DWM_FIXED)
- // lock the memory
- return (MEM_NODE *)MemoryLock(pNode);
- else
- // just return the node
- return pNode;
+ // return the node
+ return pNode;
} else {
// allocate a node for the remainder of the free block
MEM_NODE *pTemp = AllocMemNode();
@@ -326,34 +317,19 @@
// set size of node
pNode->size = size;
- if (flags & DWM_FIXED) {
- // place the free node after pNode
- pTemp->pBaseAddr = pNode->pBaseAddr + size;
- pTemp->pNext = pNode->pNext;
- pTemp->pPrev = pNode;
- pNode->pNext->pPrev = pTemp;
- pNode->pNext = pTemp;
+ // place the free node before pNode
+ pTemp->pBaseAddr = pNode->pBaseAddr;
+ pNode->pBaseAddr += freeSize;
+ pTemp->pNext = pNode;
+ pTemp->pPrev = pNode->pPrev;
+ pNode->pPrev->pNext = pTemp;
+ pNode->pPrev = pTemp;
- // check for zeroing the block
- if (flags & DWM_ZEROINIT)
- memset(pNode->pBaseAddr, 0, size);
+ // check for zeroing the block
+ if (flags & DWM_ZEROINIT)
+ memset(pNode->pBaseAddr, 0, size);
- return (MEM_NODE *)MemoryLock(pNode);
- } else {
- // place the free node before pNode
- pTemp->pBaseAddr = pNode->pBaseAddr;
- pNode->pBaseAddr += freeSize;
- pTemp->pNext = pNode;
- pTemp->pPrev = pNode->pPrev;
- pNode->pPrev->pNext = pTemp;
- pNode->pPrev = pTemp;
-
- // check for zeroing the block
- if (flags & DWM_ZEROINIT)
- memset(pNode->pBaseAddr, 0, size);
-
- return pNode;
- }
+ return pNode;
}
}
}
@@ -383,6 +359,21 @@
return NULL;
}
+
+void *MemoryAllocFixed(long size) {
+ // Allocate a fixed block of data. For now, we simply malloc it!
+ // TODO: We really should keep a list of the allocated pointers,
+ // so that we can discard them later on, when the engine quits.
+
+#ifdef SCUMM_NEED_ALIGNMENT
+ const int alignPadding = sizeof(void*) - 1;
+ size = (size + alignPadding) & ~alignPadding; //round up to nearest multiple of sizeof(void*), this ensures the addresses that are returned are alignment-safe.
+#endif
+
+ return malloc(size);
+}
+
+
/**
* Discards the specified memory object.
* @param pMemNode Node of the memory object
@@ -512,15 +503,9 @@
assert(pMemNode >= mnodeList && pMemNode <= mnodeList + NUM_MNODES - 1);
// validate the flags
- // cannot be fixed and moveable
- assert((flags & (DWM_FIXED | DWM_MOVEABLE)) != (DWM_FIXED | DWM_MOVEABLE));
+ // must be moveable
+ assert(flags & DWM_MOVEABLE);
- // cannot be fixed and discardable
- assert((flags & (DWM_FIXED | DWM_DISCARDABLE)) != (DWM_FIXED | DWM_DISCARDABLE));
-
- // must be fixed or moveable
- assert(flags & (DWM_FIXED | DWM_MOVEABLE));
-
// align the size to machine boundary requirements
size = (size + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
@@ -541,7 +526,7 @@
pMemNode->pPrev->pNext = pMemNode->pNext;
// allocate a new node
- pNew = MemoryAlloc((flags & ~DWM_FIXED) | DWM_MOVEABLE, size);
+ pNew = MemoryAlloc(flags | DWM_MOVEABLE, size);
// make sure memory allocated
assert(pNew != NULL);
@@ -560,12 +545,8 @@
FreeMemNode(pNew);
}
- if (flags & DWM_FIXED)
- // lock the memory
- return (MEM_NODE *)MemoryLock(pMemNode);
- else
- // just return the node
- return pMemNode;
+ // return the node
+ return pMemNode;
}
/**
Modified: scummvm/trunk/engines/tinsel/heapmem.h
===================================================================
--- scummvm/trunk/engines/tinsel/heapmem.h 2009-10-26 10:40:51 UTC (rev 45400)
+++ scummvm/trunk/engines/tinsel/heapmem.h 2009-10-26 10:41:11 UTC (rev 45401)
@@ -43,14 +43,13 @@
};
// allocation flags for the MemoryAlloc function
-#define DWM_FIXED 0x0001 // allocates fixed memory
-#define DWM_MOVEABLE 0x0002 // allocates movable memory
-#define DWM_DISCARDABLE 0x0004 // allocates discardable memory
-#define DWM_NOALLOC 0x0008 // when used with discardable memory - allocates a discarded block
-#define DWM_NOCOMPACT 0x0010 // does not discard memory to satisfy the allocation request
-#define DWM_ZEROINIT 0x0020 // initialises memory contents to zero
-#define DWM_SOUND 0x0040 // allocate from the sound pool
-#define DWM_GRAPHIC 0x0080 // allocate from the graphics pool
+#define DWM_MOVEABLE 0x0002 ///< allocates movable memory
+#define DWM_DISCARDABLE 0x0004 ///< allocates discardable memory
+#define DWM_NOALLOC 0x0008 ///< when used with discardable memory - allocates a discarded block
+#define DWM_NOCOMPACT 0x0010 ///< does not discard memory to satisfy the allocation request
+#define DWM_ZEROINIT 0x0020 ///< initialises memory contents to zero
+#define DWM_SOUND 0x0040 ///< allocate from the sound pool
+#define DWM_GRAPHIC 0x0080 ///< allocate from the graphics pool
// return value from the MemoryFlags function
#define DWM_DISCARDED 0x0100 // the objects memory block has been discarded
@@ -70,10 +69,14 @@
void MemoryStats(void); // Shows the maximum number of mnodes used at once
#endif
-MEM_NODE *MemoryAlloc( // allocates the specified number of bytes from the heap
+// allocates a non-fixed block with the specified number of bytes from the heap
+MEM_NODE *MemoryAlloc(
int flags, // allocation attributes
long size); // number of bytes to allocate
+// allocates a fixed block with the specified number of bytes
+void *MemoryAllocFixed(long size);
+
void MemoryDiscard( // discards the specified memory object
MEM_NODE *pMemNode); // node of the memory object
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list