ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

0.7.7b Release

This commit is contained in:
Aaron Robinson 2003-07-16 19:59:32 +00:00
parent 52a0dd2ffa
commit 0e4777b762
10 changed files with 454 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Doc/Changelog.txt
View File

@ -1,5 +1,10 @@
cxbx website: http://www.caustik.com/xbox/
version: 0.7.7b (07/16/03)
--------------------------------
- Fixed loss compatibility with X-Marbles, etc
version: 0.7.7 (07/15/03)
--------------------------------

6
Include/Cxbx.h
View File

@ -61,15 +61,15 @@ typedef signed long sint32;
// ******************************************************************
// * Define this to trace intercepted function calls
// ******************************************************************
#define _DEBUG_TRACE
//#define _DEBUG_TRACE
// ******************************************************************
// * Version information
// ******************************************************************
#ifndef _DEBUG_TRACE
#define _CXBX_VERSION "0.7.7"
#define _CXBX_VERSION "0.7.7b"
#else
#define _CXBX_VERSION "0.7.7-Trace"
#define _CXBX_VERSION "0.7.7b-Trace"
#endif
// ******************************************************************

11
Include/Win32/CxbxKrnl/EmuNtDll.h
View File

@ -508,6 +508,16 @@ typedef BOOL (NTAPI *FPTR_RtlFreeHeap)
IN PVOID lpMem
);
// ******************************************************************
// * RtlSizeHeap
// ******************************************************************
typedef SIZE_T (NTAPI *FPTR_RtlSizeHeap)
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
);
// ******************************************************************
// * RtlNtStatusToDosError
// ******************************************************************
@ -835,6 +845,7 @@ extern FPTR_NtWaitForSingleObject NtWaitForSingleObject;
extern FPTR_RtlCreateHeap RtlCreateHeap;
extern FPTR_RtlAllocateHeap RtlAllocateHeap;
extern FPTR_RtlFreeHeap RtlFreeHeap;
extern FPTR_RtlSizeHeap RtlSizeHeap;
extern FPTR_NtAllocateVirtualMemory NtAllocateVirtualMemory;
extern FPTR_NtFreeVirtualMemory NtFreeVirtualMemory;
extern FPTR_NtClearEvent NtClearEvent;

43
Include/Win32/CxbxKrnl/EmuXapi.h
View File

@ -252,6 +252,49 @@ typedef struct _RTL_HEAP_PARAMETERS
}
RTL_HEAP_PARAMETERS;
// ******************************************************************
// * func: EmuRtlCreateHeap
// ******************************************************************
PVOID WINAPI EmuRtlCreateHeap
(
IN ULONG Flags,
IN PVOID Base OPTIONAL,
IN ULONG Reserve OPTIONAL,
IN ULONG Commit,
IN BOOLEAN Lock OPTIONAL,
IN PVOID RtlHeapParams OPTIONAL
);
// ******************************************************************
// * func: EmuRtlAllocateHeap
// ******************************************************************
PVOID WINAPI EmuRtlAllocateHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN SIZE_T dwBytes
);
// ******************************************************************
// * func: EmuRtlFreeHeap
// ******************************************************************
BOOL WINAPI EmuRtlFreeHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
);
// ******************************************************************
// * func: EmuRtlSizeHeap
// ******************************************************************
SIZE_T WINAPI EmuRtlSizeHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
);
// ******************************************************************
// * func: XapiUnknownBad1
// ******************************************************************

2
Source/Win32/CxbxKrnl/EmuD3D8.cpp
View File

@ -2167,7 +2167,7 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
case X_D3DCOMMON_TYPE_PUSHBUFFER:
{
printf("*Warning: X_D3DCOMMON_TYPE_PUSHBUFFER is not yet implemented\n");
printf("*Warning* X_D3DCOMMON_TYPE_PUSHBUFFER is not yet implemented\n");
X_D3DPushBuffer *pPushBuffer = (X_D3DPushBuffer*)pResource;
}

4
Source/Win32/CxbxKrnl/EmuKrnl.cpp
View File

@ -1768,8 +1768,10 @@ XBSYSAPI EXPORTNUM(277) VOID NTAPI xboxkrnl::RtlEnterCriticalSection
}
#endif
//printf("CriticalSection->LockCount : %d\n", CriticalSection->LockCount);
// This seems redundant, but xbox software doesn't always do it
if(CriticalSection->LockCount == -1)
//if(CriticalSection->LockCount == -1)
NtDll::RtlInitializeCriticalSection((NtDll::_RTL_CRITICAL_SECTION*)CriticalSection);
NtDll::RtlEnterCriticalSection((NtDll::_RTL_CRITICAL_SECTION*)CriticalSection);

1
Source/Win32/CxbxKrnl/EmuNtDll.cpp
View File

@ -60,6 +60,7 @@ NtDll::FPTR_RtlLeaveCriticalSection NtDll::RtlLeaveCriticalSection =
NtDll::FPTR_RtlCreateHeap NtDll::RtlCreateHeap = (NtDll::FPTR_RtlCreateHeap)GetProcAddress(hNtDll, "RtlCreateHeap");
NtDll::FPTR_RtlAllocateHeap NtDll::RtlAllocateHeap = (NtDll::FPTR_RtlAllocateHeap)GetProcAddress(hNtDll, "RtlAllocateHeap");
NtDll::FPTR_RtlFreeHeap NtDll::RtlFreeHeap = (NtDll::FPTR_RtlFreeHeap)GetProcAddress(hNtDll, "RtlFreeHeap");
NtDll::FPTR_RtlSizeHeap NtDll::RtlSizeHeap = (NtDll::FPTR_RtlSizeHeap)GetProcAddress(hNtDll, "RtlSizeHeap");
NtDll::FPTR_NtWaitForSingleObject NtDll::NtWaitForSingleObject = (NtDll::FPTR_NtWaitForSingleObject)GetProcAddress(hNtDll, "NtWaitForSingleObject");
NtDll::FPTR_NtAllocateVirtualMemory NtDll::NtAllocateVirtualMemory = (NtDll::FPTR_NtAllocateVirtualMemory)GetProcAddress(hNtDll, "NtAllocateVirtualMemory");
NtDll::FPTR_NtFreeVirtualMemory NtDll::NtFreeVirtualMemory = (NtDll::FPTR_NtFreeVirtualMemory)GetProcAddress(hNtDll, "NtFreeVirtualMemory");

148
Source/Win32/CxbxKrnl/EmuXapi.cpp
View File

@ -56,6 +56,154 @@ namespace XTL
#include "EmuXTL.h"
};
// ******************************************************************
// * func: EmuRtlCreateHeap
// ******************************************************************
PVOID WINAPI XTL::EmuRtlCreateHeap
(
IN ULONG Flags,
IN PVOID Base OPTIONAL,
IN ULONG Reserve OPTIONAL,
IN ULONG Commit,
IN BOOLEAN Lock OPTIONAL,
IN PVOID RtlHeapParams OPTIONAL
)
{
EmuSwapFS(); // Win2k/XP FS
// ******************************************************************
// * debug trace
// ******************************************************************
#ifdef _DEBUG_TRACE
{
printf("EmuXapi (0x%X): EmuRtlCreateHeap\n"
"(\n"
" Flags : 0x%.08X\n"
" Base : 0x%.08X\n"
" Reserve : 0x%.08X\n"
" Commit : 0x%.08X\n"
" Lock : 0x%.08X\n"
" RtlHeapParams : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Flags, Base, Reserve, Commit, Lock, RtlHeapParams);
}
#endif
NtDll::RTL_HEAP_DEFINITION RtlHeapDefinition;
ZeroMemory(&RtlHeapDefinition, sizeof(RtlHeapDefinition));
RtlHeapDefinition.Length = sizeof(RtlHeapDefinition);
PVOID pRet = NtDll::RtlCreateHeap(Flags, Base, Reserve, Commit, Lock, &RtlHeapDefinition);
EmuSwapFS(); // XBox FS
return pRet;
}
// ******************************************************************
// * func: EmuRtlAllocateHeap
// ******************************************************************
PVOID WINAPI XTL::EmuRtlAllocateHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN SIZE_T dwBytes
)
{
EmuSwapFS(); // Win2k/XP FS
// ******************************************************************
// * debug trace
// ******************************************************************
#ifdef _DEBUG_TRACE
{
printf("EmuXapi (0x%X): EmuRtlAllocateHeap\n"
"(\n"
" hHeap : 0x%.08X\n"
" dwFlags : 0x%.08X\n"
" dwBytes : 0x%.08X\n"
");\n",
GetCurrentThreadId(), hHeap, dwFlags, dwBytes);
}
#endif
PVOID pRet = NtDll::RtlAllocateHeap(hHeap, dwFlags, dwBytes);
EmuSwapFS(); // XBox FS
return pRet;
}
// ******************************************************************
// * func: EmuRtlFreeHeap
// ******************************************************************
BOOL WINAPI XTL::EmuRtlFreeHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
)
{
EmuSwapFS(); // Win2k/XP FS
// ******************************************************************
// * debug trace
// ******************************************************************
#ifdef _DEBUG_TRACE
{
printf("EmuXapi (0x%X): EmuRtlFreeHeap\n"
"(\n"
" hHeap : 0x%.08X\n"
" dwFlags : 0x%.08X\n"
" lpMem : 0x%.08X\n"
");\n",
GetCurrentThreadId(), hHeap, dwFlags, lpMem);
}
#endif
BOOL bRet = NtDll::RtlFreeHeap(hHeap, dwFlags, lpMem);
EmuSwapFS(); // XBox FS
return bRet;
}
// ******************************************************************
// * func: EmuRtlSizeHeap
// ******************************************************************
SIZE_T WINAPI XTL::EmuRtlSizeHeap
(
IN HANDLE hHeap,
IN DWORD dwFlags,
IN PVOID lpMem
)
{
EmuSwapFS(); // Win2k/XP FS
// ******************************************************************
// * debug trace
// ******************************************************************
#ifdef _DEBUG_TRACE
{
printf("EmuXapi (0x%X): EmuRtlSizeHeap\n"
"(\n"
" hHeap : 0x%.08X\n"
" dwFlags : 0x%.08X\n"
" lpMem : 0x%.08X\n"
");\n",
GetCurrentThreadId(), hHeap, dwFlags, lpMem);
}
#endif
SIZE_T ret = NtDll::RtlSizeHeap(hHeap, dwFlags, lpMem);
EmuSwapFS(); // XBox FS
return ret;
}
// ******************************************************************
// * func: XapiUnknownBad1
// ******************************************************************

135
Source/Win32/CxbxKrnl/Xapi.1.0.4361.inl
View File

@ -32,6 +32,111 @@
// *
// ******************************************************************
// ******************************************************************
// * RtlCreateHeap
// ******************************************************************
SOOVPA<10> RtlCreateHeap_1_0_4361 =
{
0, // Large == 0
10, // Count == 10
-1, // XRef Not Saved
0, // XRef Not Used
{
// RtlCreateHeap+0x13 : push 0x0C
{ 0x13, 0x6A }, // (Offset,Value)-Pair #1
{ 0x14, 0x0C }, // (Offset,Value)-Pair #2
// RtlCreateHeap+0x1B : rep stosd
{ 0x1B, 0xF3 }, // (Offset,Value)-Pair #3
{ 0x1C, 0xAB }, // (Offset,Value)-Pair #4
// RtlCreateHeap+0x4E : retn
{ 0x4E, 0xC3 }, // (Offset,Value)-Pair #5
// RtlCreateHeap+0x8D : jnz +0x08
{ 0x8D, 0x75 }, // (Offset,Value)-Pair #6
{ 0x8E, 0x08 }, // (Offset,Value)-Pair #7
// RtlCreateHeap+0xA4 : cmp [ebp-38h], esi
{ 0xA4, 0x39 }, // (Offset,Value)-Pair #8
{ 0xA5, 0x75 }, // (Offset,Value)-Pair #9
{ 0xA6, 0xC8 }, // (Offset,Value)-Pair #10
}
};
// ******************************************************************
// * RtlAllocateHeap
// ******************************************************************
SOOVPA<11> RtlAllocateHeap_1_0_4361 =
{
0, // Large == 0
11, // Count == 11
-1, // XRef Not Saved
0, // XRef Not Used
{
// RtlAllocateHeap+0x1E : or ecx, [esi+0x18]
{ 0x1E, 0x0B }, // (Offset,Value)-Pair #1
{ 0x1F, 0x4E }, // (Offset,Value)-Pair #2
{ 0x20, 0x18 }, // (Offset,Value)-Pair #3
// RtlAllocateHeap+0x29 : jnz +0x01
{ 0x29, 0x75 }, // (Offset,Value)-Pair #4
{ 0x2A, 0x01 }, // (Offset,Value)-Pair #5
// RtlAllocateHeap+0x2B : inc eax
{ 0x2B, 0x40 }, // (Offset,Value)-Pair #6
// RtlAllocateHeap+0x73 : sub eax, 0x08
{ 0x73, 0x83 }, // (Offset,Value)-Pair #7
{ 0x74, 0xE8 }, // (Offset,Value)-Pair #8
{ 0x75, 0x08 }, // (Offset,Value)-Pair #9
// RtlAllocateHeap+0xA5 : shl edi, cl
{ 0xA5, 0xD3 }, // (Offset,Value)-Pair #10
{ 0xA6, 0xE7 }, // (Offset,Value)-Pair #11
}
};
// ******************************************************************
// * RtlFreeHeap
// ******************************************************************
SOOVPA<12> RtlFreeHeap_1_0_4361 =
{
0, // Large == 0
12, // Count == 12
-1, // XRef Not Saved
0, // XRef Not Used
{
// RtlFreeHeap+0x1F : test ecx, ecx
{ 0x1F, 0x85 }, // (Offset,Value)-Pair #1
{ 0x20, 0xC9 }, // (Offset,Value)-Pair #2
// RtlFreeHeap+0x4B : test byte ptr [edi+5], 0x08
{ 0x4B, 0xF6 }, // (Offset,Value)-Pair #3
{ 0x4C, 0x47 }, // (Offset,Value)-Pair #4
{ 0x4D, 0x05 }, // (Offset,Value)-Pair #5
{ 0x4E, 0x08 }, // (Offset,Value)-Pair #6
// RtlFreeHeap+0x5B : push 0
{ 0x5B, 0x6A }, // (Offset,Value)-Pair #7
{ 0x5C, 0x00 }, // (Offset,Value)-Pair #8
// RtlFreeHeap+0x8F : cmp [edx], edx
{ 0x8F, 0x39 }, // (Offset,Value)-Pair #9
{ 0x90, 0x12 }, // (Offset,Value)-Pair #10
// RtlFreeHeap+0xA4 : shl ebx, cl
{ 0xA4, 0xD3 }, // (Offset,Value)-Pair #11
{ 0xA5, 0xE3 }, // (Offset,Value)-Pair #12
}
};
// ******************************************************************
// * QueryPerformanceCounter
// ******************************************************************
@ -549,6 +654,36 @@ SOOVPA<10> XapiSetupPerTitleDriveLetters_1_0_4361 =
// ******************************************************************
OOVPATable XAPI_1_0_4361[] =
{
// RtlCreateHeap
{
(OOVPA*)&RtlCreateHeap_1_0_4361,
XTL::EmuRtlCreateHeap,
#ifdef _DEBUG_TRACE
"EmuRtlCreateHeap"
#endif
},
// RtlAllocateHeap
{
(OOVPA*)&RtlAllocateHeap_1_0_4361,
XTL::EmuRtlAllocateHeap,
#ifdef _DEBUG_TRACE
"EmuRtlAllocateHeap"
#endif
},
// RtlFreeHeap
{
(OOVPA*)&RtlFreeHeap_1_0_4361,
XTL::EmuRtlFreeHeap,
#ifdef _DEBUG_TRACE
"EmuRtlFreeHeap"
#endif
},
// QueryPerformanceCounter
{
(OOVPA*)&QueryPerformanceCounter_1_0_4361,

104
Source/Win32/CxbxKrnl/Xapi.1.0.4627.inl
View File

@ -32,6 +32,70 @@
// *
// ******************************************************************
// ******************************************************************
// * RtlFreeHeap
// ******************************************************************
SOOVPA<9> RtlFreeHeap_1_0_4627 =
{
0, // Large == 0
9, // Count == 9
-1, // XRef Not Saved
0, // XRef Not Used
{
// RtlFreeHeap+0x1F : test edi, edi
{ 0x1F, 0x85 }, // (Offset,Value)-Pair #1
{ 0x20, 0xFF }, // (Offset,Value)-Pair #2
// RtlFreeHeap+0x23 : mov al, 1
{ 0x23, 0xB0 }, // (Offset,Value)-Pair #3
{ 0x24, 0x01 }, // (Offset,Value)-Pair #4
// RtlFreeHeap+0x35 : mov eax, fs:[0x20]
{ 0x35, 0x64 }, // (Offset,Value)-Pair #5
{ 0x36, 0xA1 }, // (Offset,Value)-Pair #6
{ 0x37, 0x20 }, // (Offset,Value)-Pair #7
// RtlFreeHeap+0x49 : push 0x0B
{ 0x49, 0x6A }, // (Offset,Value)-Pair #8
{ 0x4A, 0x0B }, // (Offset,Value)-Pair #9
}
};
// ******************************************************************
// * RtlSizeHeap
// ******************************************************************
SOOVPA<11> RtlSizeHeap_1_0_4627 =
{
0, // Large == 0
11, // Count == 11
-1, // XRef Not Saved
0, // XRef Not Used
{
// RtlSizeHeap+0x04 : mov al, [ecx-0x0B]
{ 0x04, 0x8A }, // (Offset,Value)-Pair #1
{ 0x05, 0x41 }, // (Offset,Value)-Pair #2
{ 0x06, 0xF5 }, // (Offset,Value)-Pair #3
// RtlSizeHeap+0x07 : test al, 1
{ 0x07, 0xA8 }, // (Offset,Value)-Pair #4
{ 0x08, 0x01 }, // (Offset,Value)-Pair #5
// RtlSizeHeap+0x14 : movzx edx, word ptr [ecx-0x10]
{ 0x14, 0x0F }, // (Offset,Value)-Pair #6
{ 0x15, 0xB7 }, // (Offset,Value)-Pair #7
{ 0x16, 0x51 }, // (Offset,Value)-Pair #8
{ 0x17, 0xF0 }, // (Offset,Value)-Pair #9
// RtlSizeHeap+0x2A : sub eax, ecx
{ 0x2A, 0x2B }, // (Offset,Value)-Pair #10
{ 0x2B, 0xC1 }, // (Offset,Value)-Pair #11
}
};
// ******************************************************************
// * XapiUnknownBad1
// ******************************************************************
@ -67,6 +131,46 @@ SOOVPA<8> XapiUnknownBad1_1_0_4627 =
// ******************************************************************
OOVPATable XAPI_1_0_4627[] =
{
// RtlCreateHeap (* unchanged since 1.0.4361 *) (* OR FARTHER *)
{
(OOVPA*)&RtlCreateHeap_1_0_4361,
XTL::EmuRtlCreateHeap,
#ifdef _DEBUG_TRACE
"EmuRtlCreateHeap"
#endif
},
// RtlAllocateHeap (* unchanged since 1.0.4361 *) (* OR FARTHER *)
{
(OOVPA*)&RtlAllocateHeap_1_0_4361,
XTL::EmuRtlAllocateHeap,
#ifdef _DEBUG_TRACE
"EmuRtlAllocateHeap"
#endif
},
// RtlFreeHeap
{
(OOVPA*)&RtlFreeHeap_1_0_4627,
XTL::EmuRtlFreeHeap,
#ifdef _DEBUG_TRACE
"EmuRtlFreeHeap"
#endif
},
// RtlSizeHeap
{
(OOVPA*)&RtlSizeHeap_1_0_4627,
XTL::EmuRtlSizeHeap,
#ifdef _DEBUG_TRACE
"EmuRtlSizeHeap"
#endif
},
// XapiUnknownBad1
{
(OOVPA*)&XapiUnknownBad1_1_0_4627,